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