_, b = bits.Sub64(x[2], p256P[2], b)
	_, b = bits.Sub64(x[3], p256P[3], b)
	return int(b)
}

// p256Add sets res = x + y.
func p256Add(res, x, y *p256Element) {
	var c, b uint64
	t1 := make([]uint64, 4)
	t1[0], c = bits.Add64(x[0], y[0], 0)
	t1[1], c = bits.Add64(x[1], y[1], c)
	t1[2], c = bits.Add64(x[2], y[2], c)
	t1[3], c = bits.Add64(x[3], y[3], c)
	t2 := make([]uint64, 4)

    SMALL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, 10)
            .addValue(10L)
            .add(SHORT_NAME, 3.14f)
            .addValue(3.14d)
            .add(LONG_NAME, false)
            .add(LONG_NAME, LONG_NAME);
      }
    },
    CONDITIONAL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {

    SMALL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, 10)
            .addValue(10L)
            .add(SHORT_NAME, 3.14f)
            .addValue(3.14d)
            .add(LONG_NAME, false)
            .add(LONG_NAME, LONG_NAME);
      }
    },
    CONDITIONAL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {

        property.putAll(supplierWithValues([c: '3']))

        expect:
        assertHasNoProducer(property)
        def value = property.calculateExecutionTimeValue()
        value.isChangingValue()
        value.getChangingValue().get() == [a: '1', b: '2', c: '3']
        value.getChangingValue().get() == [a: '1b', c: '3']
    }

      AssignIfNotExists(
          ids_[idx], static_cast<CalibrationMethod>(calibration_methods_[idx]));

      const Tensor& min_tensor = context->input(3 * idx);
      const Tensor& max_tensor = context->input(3 * idx + 1);
      const Tensor& histogram_tensor = context->input(3 * idx + 2);

      const float min_value = min_tensor.scalar<float>()();
      const float max_value = max_tensor.scalar<float>()();

- login: chrisK824
  count: 3
  avatarUrl: https://avatars.githubusercontent.com/u/79946379?u=03d85b22d696a58a9603e55fbbbe2de6b0f4face&v=4
  url: https://github.com/chrisK824
- login: ryanisn
  count: 3
  avatarUrl: https://avatars.githubusercontent.com/u/53449841?v=4
  url: https://github.com/ryanisn
- login: pythonweb2
  count: 3
  avatarUrl: https://avatars.githubusercontent.com/u/32141163?v=4

        then:
        def scripts = scriptDetails()
        scripts.size() == 3 // same script applied 3 times
        scripts.collect { it.className }.unique().size() == 1
        scripts.collect { it.classpath }.unique().size() == 1
        getCompileBuildFileOperationsCount() == 8 // classpath and body for the common script + identical script x 3 targets
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

			claim.Name = fmt.Sprintf("%s-set-3", claim.Name)
			claim.Namespace = set.Namespace
			switch claimState {
			case missing:
			// Do nothing, the claim shouldn't exist.
			case exists:
				claimIndexer.Add(&claim)
			case stale:
				claim.SetOwnerReferences([]metav1.OwnerReference{
					{
						Name:       "set-3",
						UID:        types.UID("stale"),
						APIVersion: "v1",

type digest struct {
	s   [4]uint32
	x   [BlockSize]byte
	nx  int
	len uint64
}

func (d *digest) Reset() {
	d.s[0] = init0
	d.s[1] = init1
	d.s[2] = init2
	d.s[3] = init3
	d.nx = 0
	d.len = 0
}

const (
	magic         = "md5\x01"
	marshaledSize = len(magic) + 4*4 + BlockSize + 8
)

func (d *digest) MarshalBinary() ([]byte, error) {

(FMOVDload [off] {sym} (ADDshiftLL [3] ptr idx) mem) && off == 0 && sym == nil => (FMOVDloadidx8 ptr idx mem)
(FMOVSload [off] {sym} (ADDshiftLL [2] ptr idx) mem) && off == 0 && sym == nil => (FMOVSloadidx4 ptr idx mem)
(FMOVDloadidx ptr (SLLconst [3] idx) mem) => (FMOVDloadidx8 ptr idx mem)
(FMOVSloadidx ptr (SLLconst [2] idx) mem) => (FMOVSloadidx4 ptr idx mem)
(FMOVDloadidx (SLLconst [3] idx) ptr mem) => (FMOVDloadidx8 ptr idx mem)