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