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