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