splitOf     SlKeyIdx // idx in slkeys slice in slotCanonicalizer
	splitOffset int64
}

// lookup looks up a LocalSlot in the slot canonicalizer "sc", returning
// a canonical index for the slot, and adding it to the table if need
// be. Return value is the canonical slot index, and a boolean indicating
// whether the slot was found in the table already (TRUE => found).

    if [ "$(uname -s)" == "Darwin" ]; then
      # We want this print just the way it is
      # shellcheck disable=SC2016
      echo 'On macOS we recommend using homebrew and adding "$(brew --prefix openssl)/bin" to your PATH'
    fi
    exit 1
  fi

  # we use gcloud to create the cluster, gsutil to stage binaries and data
  for cmd in gcloud gsutil; do

	m.podStateProvider.(*fakePodStateProvider).removed = map[types.UID]struct{}{pod.UID: {}}

	// GetPodStatus and the following SyncPod will not return errors in the
	// case where the pod has been deleted. We are not adding any pods into
	// the fakePodProvider so they are 'deleted'.
	podStatus, err := m.GetPodStatus(ctx, pod.UID, pod.Name, pod.Namespace)
	assert.NoError(t, err)

//
// # Module maintenance
//
// Go mod provides access to operations on modules.
//
// Note that support for modules is built into all the go commands,
// not just 'go mod'. For example, day-to-day adding, removing, upgrading,
// and downgrading of dependencies should be done using 'go get'.
// See 'go help modules' for an overview of module functionality.
//
// Usage:
//
//	go mod <command> [arguments]

				},
			},
		},
	}
	for _, tc := range tests {
		if tc.existingPodAllocation != nil {
			// when kubelet restarts, AllocatedResources has already existed before adding pod
			err := kubelet.statusManager.SetPodAllocation(tc.existingPodAllocation)
			if err != nil {
				t.Fatalf("failed to set pod allocation: %v", err)
			}
		}
		kubelet.HandlePodAdditions([]*v1.Pod{tc.pod})

    }
    rewriter.replaceOp(op, {add});
    return success();
  }
};

// Conterts tf.Conv2D to mhlo.dynamic_conv.
// TODO(disc): To recover static special case's performance with adding folding,
// canonicalization func and removing ConvertConvOp.
template <typename OpT, int num_spatial_dims, bool depthwise_conv = false>
class ConvertConvDynamic : public OpRewritePattern<OpT> {
 public:

  }
  return tensorflow::GetTypeFromTFTensorShape(output_dims, element_type);
}

// TODO(hanxiongwang): The logic in this function need move to Op Verify method
// when dependecy issue of adding header file
// "third_party/tensorflow/compiler/xla/xla_data.pb.h" into
// "third_party/tensorflow/compiler/mlir/tensorflow/ir/tf_ops_n_z.cc" is
// resolved
LogicalResult PrecheckForXlaConvV2Op(XlaConvV2Op op) {

				actual = job
				return job, nil
			}
			if err := sharedInformerFactory.Batch().V1().Jobs().Informer().GetIndexer().Add(job); err != nil {
				t.Fatalf("error %v while adding the %v job to the index", err, klog.KObj(job))
			}

			if err := manager.syncJob(ctx, testutil.GetKey(job, t)); err != nil {
				t.Fatalf("error %v while reconciling the job %v", err, testutil.GetKey(job, t))
			}

  let summary = [{
Adds sparse `updates` to an existing tensor according to `indices`.
  }];

  let description = [{
This operation creates a new tensor by adding sparse `updates` to the passed
in `tensor`.
This operation is very similar to `tf.compat.v1.scatter_nd_add`, except that the
updates are added onto an existing tensor (as opposed to a variable). If the