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