var states []string
	if obj.DeletionTimestamp != nil {
		states = append(states, "deleted")
	}
	if obj.Status.Allocation == nil {
		if obj.DeletionTimestamp == nil {
			states = append(states, "pending")
		}
	} else {
		states = append(states, "allocated")
		if len(obj.Status.ReservedFor) > 0 {
			states = append(states, "reserved")

		ts.Config.ConnState = func(c net.Conn, state ConnState) {
			if c == nil {
				t.Errorf("nil conn seen in state %s", state)
				return
			}
			sl := <-activeLog
			if sl.active == nil && state == StateNew {
				sl.active = c
			} else if sl.active != c {
				t.Errorf("unexpected conn in state %s", state)
				activeLog <- sl
				return
			}

      // TODO: b/326332748 - For forward convolution in transpose_conv,
      // IsSamePadding calculation may need to be updated.
      // Reference: https://arxiv.org/pdf/1603.07285.pdf
      // Section 4.6 > Relationship 13 states `stride_dim = dilation + 1`.
      rewriter.replaceOpWithNewOp<TFL::TransposeConvOp>(
          // op result should be recasted to desired quantized type.
          op, output_type, /*output_shape=*/

      // The reduce function __reduce_func has 36 arguments, and the source of those arguments are listed below:
      //   [arg0, arg5]:   these are states coming from ReduceDatasetOp's [arg1, arg6]
      //   [arg6: arg14]:  these are the input elements coming from the output of %51:9
      //   [arg15: arg35]: these are the captured elements from ReduceDatasetOp's [arg7:arg27]

    // Projection weight and bias
    TFL_TensorOfOrNone<[F32, QI8]>:$projection_weights,
    // Optional input
    TFL_TensorOfOrNone<[F32, QI32]>:$projection_bias,

    // Stateful activation and cell states.
    TFL_StatefulTensor:$input_activation_state,
    TFL_StatefulTensor:$input_cell_state,

    // Layer norm coefficients
    TFL_TensorOfOrNone<[F32, QI16]>:$input_layer_norm_coefficients,

  input_shapes.reserve(op.getArgs().size());
  for (mlir::Type type : op.getArgs().getTypes()) {
    input_shapes.push_back(xla::TypeToShape(type));
  }

  absl::Status status = loader->RefineDynamicShapes(input_shapes);
  if (!status.ok()) {
    // Do not return false here.
    //
    // RefineDynamicShapes returns ok only when it produces full static shapes.

	// statusManager receives updated pod status updates from the podWorker and updates the API
	// status of those pods to match. The statusManager is authoritative for the synthesized
	// status of the pod from the kubelet's perspective (other components own the individual
	// elements of status) and should be consulted by components in preference to assembling
	// that status themselves. Note that the status manager is downstream of the pod worker

// its String method returns "<invalid Value>", and all other methods panic.
// Most functions and methods never return an invalid value.
// If one does, its documentation states the conditions explicitly.
//
// A Value can be used concurrently by multiple goroutines provided that
// the underlying Go value can be used concurrently for the equivalent
// direct operations.
//

tn.us
tx.us
ut.us
vi.us
vt.us
va.us
wa.us
wi.us
wv.us
wy.us
// The registrar notes several more specific domains available in each state,
// such as state.*.us, dst.*.us, etc., but resolution of these is somewhat
// haphazard; in some states these domains resolve as addresses, while in others
// only subdomains are available, or even nothing at all. We include the

	}
	pp := gp.m.p.ptr()
	if pp.m.ptr() != gp.m || pp.status != _Prunning {
		print("releasep: m=", gp.m, " m->p=", gp.m.p.ptr(), " p->m=", hex(pp.m), " p->status=", pp.status, "\n")
		throw("releasep: invalid p state")
	}
	gp.m.p = 0
	pp.m = 0
	pp.status = _Pidle
	return pp
}

func incidlelocked(v int32) {
	lock(&sched.lock)
	sched.nmidlelocked += v
	if v > 0 {
		checkdead()
	}