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