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