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