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