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