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