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