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