return true
	case DIVD, DIVDCC, DIVDU, DIVDUCC, DIVDE, DIVDECC, DIVDEU, DIVDEUCC, DIVDO, DIVDOCC, DIVDUO, DIVDUOCC:
		return true
	case MODUD, MODSD, MODUW, MODSW:
		return true
	case FADD, FADDS, FSUB, FSUBS, FMUL, FMULS, FDIV, FDIVS, FMADD, FMADDS, FMSUB, FMSUBS, FNMADD, FNMADDS, FNMSUB, FNMSUBS, FMULSCC:
		return true
	case FADDCC, FADDSCC, FSUBCC, FMULCC, FDIVCC, FDIVSCC:
		return true

		parent := &common{name: tc.parent}
		if tc.parent != "" {
			parent.level = 1
		}
		if n, ok, partial := m.fullName(parent, tc.sub); ok != tc.ok || partial != tc.partial {
			t.Errorf("for pattern %q, fullName(parent=%q, sub=%q) = %q, ok %v partial %v; want ok %v partial %v",
				tc.pattern, tc.parent, tc.sub, n, ok, partial, tc.ok, tc.partial)
		}
	}
}

var namingTestCases = []struct{ name, want string }{
	// Uniqueness

				p.From.Name = obj.NAME_EXTERN
				p.From.Offset = 0
			}
		}
	}

	// Rewrite SUB constants into ADD.
	switch p.As {
	case ASUBC:
		if p.From.Type == obj.TYPE_CONST && isint32(-p.From.Offset) {
			p.From.Offset = -p.From.Offset
			p.As = AADDC
		}

	case ASUB:
		if p.From.Type == obj.TYPE_CONST && isint32(-p.From.Offset) {
			p.From.Offset = -p.From.Offset
			p.As = AADD
		}

		ir.ODIV,
		ir.ODOT,
		ir.ODOTTYPE,
		ir.OLITERAL,
		ir.OLSH,
		ir.OMOD,
		ir.OMUL,
		ir.ONEG,
		ir.ONIL,
		ir.OOR,
		ir.OOROR,
		ir.OPAREN,
		ir.OPLUS,
		ir.ORSH,
		ir.OSUB,
		ir.OXOR:
		return false
	}

	// Be conservative.
	return true
}

// expand append(l1, l2...) to
//
//	init {
//	  s := l1
//	  newLen := s.len + l2.len

		// It is sufficient to look at the first sub-error only.
		msg := err.desc[0].msg
		if strings.Index(msg, "invalid operand") > 0 || strings.Index(msg, "invalid type") > 0 {
			return
		}
	}

	if check.conf._Trace {
		check.trace(err.posn().Pos(), "ERROR: %s (code = %d)", err.desc[0].msg, err.code)
	}

	// In go/types, if there is a sub-error with a valid position,

		mips.ACMPGTF, mips.ACMPGTD:
		return true
	}
	return false
}

// IsMIPSMUL reports whether the op (as defined by an mips.A* constant) is
// one of the MUL/DIV/REM/MADD/MSUB instructions that require special handling.
func IsMIPSMUL(op obj.As) bool {
	switch op {
	case mips.AMUL, mips.AMULU, mips.AMULV, mips.AMULVU,
		mips.ADIV, mips.ADIVU, mips.ADIVV, mips.ADIVVU,

	AORIS
	AREM
	AREMU
	ARFI
	ARLWMI
	ARLWMICC
	ARLWNM
	ARLWNMCC
	ACLRLSLWI
	ASLW
	ASLWCC
	ASRW
	ASRAW
	ASRAWCC
	ASRWCC
	ASTBCCC
	ASTHCCC
	ASTSW
	ASTWCCC
	ASUB
	ASUBCC
	ASUBVCC
	ASUBC
	ASUBCCC
	ASUBCV
	ASUBCVCC
	ASUBME
	ASUBMECC
	ASUBMEVCC
	ASUBMEV
	ASUBV
	ASUBE
	ASUBECC
	ASUBEV
	ASUBEVCC
	ASUBZE
	ASUBZECC

			}
		}
	}
}

func TestMagicUnsigned(t *testing.T) {
	One := new(big.Int).SetUint64(1)
	for _, n := range [...]uint{8, 16, 32, 64} {
		TwoN := new(big.Int).Lsh(One, n)
		Max := new(big.Int).Sub(TwoN, One)
		for _, c := range [...]uint64{
			3,
			5,
			6,
			7,
			9,
			10,
			11,
			12,
			13,
			14,
			15,
			17,
			1<<8 - 1,
			1<<8 + 1,
			1<<16 - 1,
			1<<16 + 1,

	/*8513*/ uint16(xSetOp), uint16(SUB),
	/*8515*/ uint16(xReadIw),
	/*8516*/ uint16(xArgAX),
	/*8517*/ uint16(xArgImm16),
	/*8518*/ uint16(xMatch),
	/*8519*/ uint16(xSetOp), uint16(SUB),
	/*8521*/ uint16(xReadId),
	/*8522*/ uint16(xArgEAX),
	/*8523*/ uint16(xArgImm32),
	/*8524*/ uint16(xMatch),
	/*8525*/ uint16(xCondDataSize), 8513, 8519, 8529,
	/*8529*/ uint16(xSetOp), uint16(SUB),
	/*8531*/ uint16(xReadId),

}

func (trh *timingRatioHistogramInner) Sub(deltaNumerator float64) {
	trh.Add(-deltaNumerator)
}

func (trh *timingRatioHistogramInner) Inc() {
	trh.Add(1)
}

func (trh *timingRatioHistogramInner) Dec() {
	trh.Add(-1)
}

func (trh *timingRatioHistogramInner) SetToCurrentTime() {
	trh.Set(float64(trh.nowFunc().Sub(time.Unix(0, 0))))
}