ADD	$16, INP
	VXOR	INOUT, V6, INOUT
	CIPHER_BLOCK(INOUT, IVEC, INOUT, VCIPHER, VCIPHERLAST, Lcbc_enc10, Lcbc_enc12)
	VOR	INOUT, INOUT, IVEC // ciphertext (INOUT) is IVEC for next block.
	P8_STXVB16X(INOUT, OUTP, R0)
	ADD	$16, OUTP
	BDNZ	Lcbc_enc

	P8_STXVB16X(INOUT, IVP, R0)
	CLEAR_KEYS()
	RET

	PCALIGN $16
Lcbc_dec:
	P8_LXVB16X(INP, R0, TMP)
	ADD	$16, INP

            public class MyTest {
                @org.junit.Test public void works() throws Exception {
                    System.out.print("out1");
                    System.err.print("err1");
                }
                @org.junit.Test public void fails() throws Exception {
                    System.out.print("out2");
                    System.err.print("err2");
                    org.junit.Assert.fail();
                }
            }

			// 1ns.
			out1 := Event{
				ctx: schedCtx{
					G: GoID(ev.G),
					P: ProcID(ev.P),
					M: it.procMs[ProcID(ev.P)],
				},
				table: it.evt,
				base: baseEvent{
					typ:  go122.EvGoSyscallBegin,
					time: Time(ev.Ts),
					args: timedEventArgs{1: uint64(ev.StkID)},
				},
			}

			out2 := Event{
				ctx:   out1.ctx,
				table: it.evt,
				base: baseEvent{

			cmd := exec.Command(exe, []string{"-mode", s.mode}...)
			out, _ := cmd.CombinedOutput()
			outs := strings.ReplaceAll(string(out), "\n", " ")
			outs = strings.TrimSpace(outs)
			if s.expected != "" && s.expected != outs {
				t.Fatalf("failed%s mode %s: wanted %q\noutput:\n%s", bt,
					s.mode, s.expected, outs)
			}
			for _, need := range s.musthave {
				if !strings.Contains(outs, need) {

  }];

  let arguments = (ins);

  let results = (outs
    Res<TF_Int32Tensor, [{A vector containing the global TPU id of each TPU on the host.}]>:$output
  );
}

def TF_ShutdownTPUSystemOp : TF_Op<"ShutdownTPUSystem", []> {
  let summary = [{
An op that shuts down the TPU system.
  }];

  let arguments = (ins);
  let results = (outs
    TF_BoolTensor:$success
  );
}

  );

  let results = (outs);
}


def TFL_HashtableSizeOp: TFL_Op<"hashtable_size", []> {
  let summary = "Computes the number of elements in the given table.";

  let arguments = (ins
    TFL_ResourceTensor:$hash_table
  );

  let results = (outs
    TFL_I64Tensor:$out
  );
}

def TFL_BroadcastArgsOp : TFL_Op<"broadcast_args",[

    in_ch and out_ch are for control dependencies.
  }];

  let arguments = (ins
    TFRT_ChainType:$in_ch,
    TFTensorType:$arg,
    StrAttr:$device,
    I64Attr:$index
  );

  let results = (outs
    TFRT_ChainType:$out_ch
  );

  let assemblyFormat = "operands attr-dict";
}

def GetResourceOp : FallbackAsync_Op<"get_resource",
    [CoreRT_TypedAttributeTrait,

	if _, err := outf.Seek(int64(dwarfCmdOffset), 0); err != nil {
		return err
	}
	if _, err := io.CopyN(outf, bytes.NewReader(realdwarf.Raw()), int64(realdwarf.Len)); err != nil {
		return err
	}
	if _, err := outf.Seek(int64(unsafe.Offsetof(exem.FileHeader.Ncmd)), 0); err != nil {
		return err
	}
	if err := binary.Write(outf, exem.ByteOrder, exem.Ncmd+1); err != nil {
		return err
	}

  );

  let results = (outs
    TF_NumberTensor:$out
  );

  TF_DerivedOperandTypeAttr T = TF_DerivedOperandTypeAttr<0>;
  TF_DerivedOperandTypeAttr Tidx = TF_DerivedOperandTypeAttr<1>;

  let hasVerifier = 1;
}

def TF_CumsumOp : TF_Op<"Cumsum", [Pure, TF_AllTypesMatch<["x", "out"]>]> {

// QDQ-NEXT: %[[out1:.*]] = "tfl.dequantize"(%[[split]]#0) : (tensor<2x!quant.uniform<u8:f32, 1.000000e+00>>) -> tensor<2xf32>
// QDQ-NEXT: %[[out2:.*]] = "tfl.dequantize"(%[[split]]#1) : (tensor<2x!quant.uniform<u8:f32, 1.000000e+00>>) -> tensor<2xf32>
// QDQ-NEXT: return %[[out1]], %[[out2]] : tensor<2xf32>, tensor<2xf32>
}

// CHECK-LABEL: RemoveTrival