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