if (length >= 8) {
      long mul = K2 + length * 2L;
      long a = load64(bytes, offset) + K2;
      long b = load64(bytes, offset + length - 8);
      long c = rotateRight(b, 37) * mul + a;
      long d = (rotateRight(a, 25) + b) * mul;
      return hashLength16(c, d, mul);
    }
    if (length >= 4) {
      long mul = K2 + length * 2;
      long a = load32(bytes, offset) & 0xFFFFFFFFL;

    long mul = K3;
    int topBit = 0x7;

    int lengthAligned = length & ~topBit;
    int lengthRemainder = length & topBit;
    long hash = seed ^ (length * mul);

    for (int i = 0; i < lengthAligned; i += 8) {
      long loaded = load64(bytes, offset + i);
      long data = shiftMix(loaded * mul) * mul;
      hash ^= data;
      hash *= mul;
    }

		FieldD string `gorm:"uniqueIndex;index"` // uniqueIndex and index

		FieldE1 string `gorm:"uniqueIndex:uniq_field_e1_e2"` // mul uniqueIndex
		FieldE2 string `gorm:"uniqueIndex:uniq_field_e1_e2"`

		FieldF1 string `gorm:"uniqueIndex:uniq_field_f1_f2;index"` // mul uniqueIndex and index
		FieldF2 string `gorm:"uniqueIndex:uniq_field_f1_f2;"`

		FieldG string `gorm:"unique;uniqueIndex"` // unique and uniqueIndex

          command: [
            "/bin/sh",
            "-ce",

var t0 = new(P256Element) var t1 = new(P256Element) z.Square(x) z.Mul(x, z) z.Square(z) z.Mul(x, z) t0.Square(z) for s := 1; s < 3; s++ { t0.Square(t0) } t0.Mul(z, t0) t1.Square(t0) for s := 1; s < 6; s++ { t1.Square(t1) } t0.Mul(t0, t1) for s := 0; s < 3; s++ { t0.Square(t0) } z.Mul(z, t0) t0.Square(z) t0.Mul(x, t0) t1.Square(t0) for s := 1; s < 16; s++ { t1.Square(t1) } t0.Mul(t0, t1) for s := 0; s < 15; s++ { t0.Square(t0) } z.Mul(z, t0) for s := 0; s < 17; s++ { t0.Square(t0) } t0.Mul(x, t0) for...

}

absl::Status MulModel(AbstractContext* ctx,
                      absl::Span<AbstractTensorHandle* const> inputs,
                      absl::Span<AbstractTensorHandle*> outputs) {
  return ops::Mul(ctx, inputs[0], inputs[1], &outputs[0], "Mul");
}

// TODO(vnvo2409): Add more tests from `python/ops/gradient_checker_v2_test.py`.
// These tests should not be confused with `[*]_grad_test` which compare the

var t0 = new(P256Element) var t1 = new(P256Element) z.Square(x) z.Mul(x, z) z.Square(z) z.Mul(x, z) t0.Square(z) for s := 1; s < 3; s++ { t0.Square(t0) } t0.Mul(z, t0) t1.Square(t0) for s := 1; s < 6; s++ { t1.Square(t1) } t0.Mul(t0, t1) for s := 0; s < 3; s++ { t0.Square(t0) } z.Mul(z, t0) t0.Square(z) t0.Mul(x, t0) t1.Square(t0) for s := 1; s < 16; s++ { t1.Square(t1) } t0.Mul(t0, t1) for s := 0; s < 15; s++ { t0.Square(t0) } z.Mul(z, t0) for s := 0; s < 17; s++ { t0.Square(t0) } t0.Mul(x, t0) for...

                  TF_Status* s, const char* name) {
  return MinWithDevice(l, r, graph, /*op_device=*/"", s, name);
}

TF_Operation* Mul(TF_Operation* l, TF_Operation* r, TF_Graph* graph,
                  TF_Status* s, const char* name) {
  TF_Operation* op;
  BinaryOpHelper("Mul", l, r, graph, s, name, &op, "", true);
  return op;
}

TF_Operation* Add(TF_Output l, TF_Output r, TF_Graph* graph, TF_Status* s,

	BREAK				// 00002a00
	UNDEF				// 00002a00

	ANDN	R4, R5, R6		// a6901600
	ANDN	R4, R5			// a5901600
	ORN	R4, R5, R6		// a6101600
	ORN	R4, R5			// a5101600

	// mul
	MUL	R4, R5	  		// a5101c00
	MUL	R4, R5, R6	  	// a6101c00
	MULW	R4, R5	  		// a5101c00
	MULW	R4, R5, R6	  	// a6101c00
	MULV	R4, R5	   		// a5901d00
	MULV	R4, R5, R6	   	// a6901d00
	MULVU	R4, R5			// a5901d00

	// In some db (e.g. MySQL), Unique and UniqueIndex are indistinguishable.
	// When a column has a (not Mul) UniqueIndex, Migrator always reports its gorm.ColumnType is Unique.
	// It causes field unnecessarily migration.
	// Therefore, we need to record the UniqueIndex on this column (exclude Mul UniqueIndex) for MigrateColumnUnique.
	UniqueIndex string
}

func (field *Field) BindName() string {