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