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