return

bad:
	ctxt.Diag("asmand: bad address %v", obj.Dconv(p, a))
}

func (ab *AsmBuf) asmand(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr, ra *obj.Addr) {
	ab.asmandsz(ctxt, cursym, p, a, reg[ra.Reg], regrex[ra.Reg], 0)
}

func (ab *AsmBuf) asmando(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr, o int) {
	ab.asmandsz(ctxt, cursym, p, a, o, 0, 0)
}

	"MOVFV",
	"MOVDV",
	"MOVVF",
	"MOVVD",
	"AMSWAPB",
	"AMSWAPH",
	"AMSWAPW",
	"AMSWAPV",
	"AMCASB",
	"AMCASH",
	"AMCASW",
	"AMCASV",
	"AMADDW",
	"AMADDV",
	"AMANDW",
	"AMANDV",
	"AMORW",
	"AMORV",
	"AMXORW",
	"AMXORV",
	"AMMAXW",
	"AMMAXV",
	"AMMINW",
	"AMMINV",
	"AMMAXWU",
	"AMMAXVU",
	"AMMINWU",
	"AMMINVU",
	"AMSWAPDBB",
	"AMSWAPDBH",

	case asmSlice:
		cc = append(cc, newComponent(suffix+"_base", asmKind(arch.ptrSize), "slice base", off, arch.ptrSize, suffix))
		cc = append(cc, newComponent(suffix+"_len", asmKind(arch.intSize), "slice len", off+arch.ptrSize, arch.intSize, suffix))

	AMCASH		R14, (R13), R12 // acb95838
	AMCASW		R14, (R13), R12 // ac395938
	AMCASV		R14, (R13), R12 // acb95938
	AMADDW		R14, (R13), R12 // ac396138
	AMADDV		R14, (R13), R12 // acb96138
	AMANDW		R14, (R13), R12 // ac396238
	AMANDV		R14, (R13), R12 // acb96238
	AMORW		R14, (R13), R12 // ac396338
	AMORV		R14, (R13), R12 // acb96338
	AMXORW		R14, (R13), R12 // ac396438
	AMXORV		R14, (R13), R12 // acb96438

	AMOVVF
	AMOVVD

	// 2.2.7. Atomic Memory Access Instructions
	AAMSWAPB
	AAMSWAPH
	AAMSWAPW
	AAMSWAPV
	AAMCASB
	AAMCASH
	AAMCASW
	AAMCASV
	AAMADDW
	AAMADDV
	AAMANDW
	AAMANDV
	AAMORW
	AAMORV
	AAMXORW
	AAMXORV
	AAMMAXW
	AAMMAXV
	AAMMINW
	AAMMINV
	AAMMAXWU
	AAMMAXVU
	AAMMINWU
	AAMMINVU
	AAMSWAPDBB
	AAMSWAPDBH
	AAMSWAPDBW
	AAMSWAPDBV

// tf_executor.island {_parallel_execution_ids=r0:0,p0:0} wraps "tf.OpC"
// tf_executor.island {_parallel_execution_ids=r0:0,p0:1} wraps "tf.OpD"
// tf_executor.island {_parallel_execution_ids=r0:1} wraps "tf.OpB"
// tf_executor.island {_parallel_execution_ids=r0:1,p0:0} wraps "tf.OpC"
// tf_executor.island {_parallel_execution_ids=r0:1,p0:1} wraps "tf.OpD"
//
// "tf.OpA" will not have `_parallel_execution_ids` attr,

}

mlir::LogicalResult IslandOp::verify() {
  IslandOp island = *this;
  if (!island.GetBody().args_empty())
    return island.emitOpError() << "expects body without any arguments";

  Operation &yield = island.GetBody().back();
  if (!isa<YieldOp>(yield))
    return yield.emitOpError()
           << "invalid tf_executor.island terminator, yield expected";

        %0 = tf_executor.graph {
          %outputs, %control = tf_executor.island wraps "tf.XlaSharding"(%arg0) {_XlaSharding = "\08\03\1A\02\02\01\22\02\00\01", sharding = "\08\03\1A\02\02\01\22\02\00\01"} : (tensor<2x2xf32>) -> tensor<2x2xf32>

	}

	AssertAssociationCount(t, user2, "Team", 0, "after clear")
}

func TestHasManyAssociationForSlice(t *testing.T) {
	users := []User{
		*GetUser("slice-hasmany-1", Config{Pets: 2}),
		*GetUser("slice-hasmany-2", Config{Pets: 0}),
		*GetUser("slice-hasmany-3", Config{Pets: 4}),
	}

	DB.Create(&users)

	// Count
	AssertAssociationCount(t, users, "Pets", 6, "")

	// Find
	var pets []Pet

)

// GenerateDeltas computes Workload resources. This is design to be highly optimized to delta updates,
// and supports *on-demand* client usage. A client can subscribe with a wildcard subscription and get all
// resources (with delta updates), or on-demand and only get responses for specifically subscribed resources.
//