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