secondLine.put("@timestamp", item.getTimestamp());

        try (OutputStream out1 = getXContentOutputStream(firstLineMap); OutputStream out2 = getXContentOutputStream(secondLine)) {
            return ((ByteArrayOutputStream) out1).toString(CoreLibConstants.UTF_8) + '\n'
                    + ((ByteArrayOutputStream) out2).toString(CoreLibConstants.UTF_8);
        } catch (final IOException e) {

			// 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",[

            continue entries;
          }
        }
        if (outI < i) { // if outI == i don't bother writing the values back where they came from
          alternatingKeysAndValues[outKeyIndex] = key;
          alternatingKeysAndValues[outKeyIndex ^ 1] = value;
        }
        outI++;
      }
      return outI == n ? hashTable : new Object[] {hashTable, outI, duplicateKey};
    } else if (tableSize <= SHORT_MAX_SIZE) {
      /*

    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