private long sync(long syncMillis) {
        long newSyncMillis = advance(timeSource.currentTimeMillis());
        syncMillisRef.compareAndSet(syncMillis, newSyncMillis);
        return newSyncMillis;
    }

    /**
     * Advance the clock to the given timestamp and return the new time.
     * The returned time may not be the one passed in, in case another thread already advanced the clock further.

	1<<_Switch |
	1<<_Type |
	1<<_Var

// advance consumes tokens until it finds a token of the stopset or followlist.
// The stopset is only considered if we are inside a function (p.fnest > 0).
// The followlist is the list of valid tokens that can follow a production;
// if it is empty, exactly one (non-EOF) token is consumed to ensure progress.
func (p *parser) advance(followlist ...token) {
	if trace {

	// Infinite copy loops may happen in unreachable code.
	// (TODO: or can they? Needs a test.)
	slow := w
	var advance bool
	for w.Op == OpCopy {
		w = w.Args[0]
		if w == slow {
			w.reset(OpUnknown)
			break
		}
		if advance {
			slow = slow.Args[0]
		}
		advance = !advance
	}

	// The answer is w.  Update all the copies we saw
	// to point directly to w.  Doing this update makes

    // can return a temporary object (and of type other then T), so just
    // having "return &*iterator_;" doesn't work.
    // value_ is updated here and not in Advance() because Advance()
    // can advance iterator_ beyond the end of the range, and we cannot
    // detect that fact. The client code, on the other hand, is
    // responsible for not calling Current() on an out-of-range iterator.
    virtual const T* Current() const {

  SmallVector<Attribute> function_list;
  llvm::DenseMap<SymbolRefAttr, int> called_indexes;

  WalkResult result = module.walk([&](stablehlo::CustomCallOp op) {
    if (!IsTfFuncCustomCall(op)) {
      return WalkResult::advance();
    }

    auto backend_config =
        op->getAttrOfType<DictionaryAttr>(kTfBackendConfigAttrName);
    if (!backend_config) {
      op->emitOpError() << "is missing attribute '" << kTfBackendConfigAttrName

	"internal/trace/version"
)

// ordering emulates Go scheduler state for both validation and
// for putting events in the right order.
//
// The interface to ordering consists of two methods: Advance
// and Next. Advance is called to try and advance an event and
// add completed events to the ordering. Next is used to pick
// off events in the ordering.
type ordering struct {
	gStates     map[GoID]*gState

    // Skip non-tpu device cluster_func.
    auto cluster_id =
        cluster_func_op->getAttrOfType<StringAttr>(TF::kReplicationInfoAttr);
    if (!cluster_id) return WalkResult::advance();

    llvm::SmallVector<int, 4> dynamic_shape_arg_index;

    // Traverse the operands of the cluster func op and find which operand
    // is returned by TPUAnnotateTensorsWithDynamicShapeOp.

    auto abstractOp = op->getRegisteredInfo();
    if (!abstractOp) return WalkResult::advance();

    if (mlir::mhlo::IsDynamicPadderOp(abstractOp->getTypeID())) {
      has_dynamic_op = true;
      dynamism_op_counter->GetCell(op->getName().getStringRef().str())
          ->IncrementBy(1);
    }

    return WalkResult::advance();
  });

  if (has_dynamic_op) {

	SHA512ROUND0(V0, V1, V2, V3, V4, V5, V6, V7, V8, R_x020)
	LXVD2X	(INP)(R_x000), VS42	// load v10 (=vs42) in advance
	VSLDOI	$8, V8, V8, V9
	SHA512ROUND0(V7, V0, V1, V2, V3, V4, V5, V6, V9, R_x030)
	VPERMLE(V10,V10,LEMASK,V10)
	SHA512ROUND0(V6, V7, V0, V1, V2, V3, V4, V5, V10, R_x040)
	LXVD2X	(INP)(R_x010), VS44	// load v12 (=vs44) in advance
	VSLDOI	$8, V10, V10, V11
	SHA512ROUND0(V5, V6, V7, V0, V1, V2, V3, V4, V11, R_x050)

      return WalkResult::advance();
    Operation* compile_launch_op = compile_op->getParentOp();

    if (compile_launch_op->getBlock() == preprocess_or_launch->getBlock() &&
        preprocess_or_launch->isBeforeInBlock(compile_launch_op)) {
      tpu_compile_successor = compile_op;
      return WalkResult::interrupt();
    }
    return WalkResult::advance();
  });
  return tpu_compile_successor;
}