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