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