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