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