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