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