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