function renderRoot(root, isYieldy, isExpired) {
  !!isWorking
    ? invariant(
        false,
        'renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.',
      )
    : void 0
  isWorking = true
  ReactCurrentOwner$2.currentDispatcher = Dispatcher

  // console.log(isYieldy, isExpired)
  logRootTimes('start', root)

  var expirationTime = root.nextExpirationTimeToWorkOn
  console.log(expirationTime, nextRenderExpirationTime)

  var prevInteractions = null
  if (enableSchedulerTracing) {
    prevInteractions = tracing.__interactionsRef.current
    tracing.__interactionsRef.current = root.memoizedInteractions
  }

  // Check if we're starting from a fresh stack, or if we're resuming from
  // previously yielded work.
  if (
    expirationTime !== nextRenderExpirationTime ||
    root !== nextRoot ||
    nextUnitOfWork === null
  ) {
    // Reset the stack and start working from the root.
    resetStack()
    nextRoot = root
    nextRenderExpirationTime = expirationTime
    nextUnitOfWork = createWorkInProgress(
      nextRoot.current,
      null,
      nextRenderExpirationTime,
    )
    root.pendingCommitExpirationTime = NoWork
  }

  var didFatal = false

  startWorkLoopTimer(nextUnitOfWork)

  do {
    try {
      workLoop(isYieldy)
    } catch (thrownValue) {
      if (nextUnitOfWork === null) {
        // This is a fatal error.
        didFatal = true
        onUncaughtError(thrownValue)
      } else {
        {
          // Reset global debug state
          // We assume this is defined in DEV
          resetCurrentlyProcessingQueue()
        }

        var failedUnitOfWork = nextUnitOfWork
        if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
          replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy)
        }
        !(nextUnitOfWork !== null)
          ? invariant(
              false,
              'Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it.',
            )
          : void 0

        var sourceFiber = nextUnitOfWork
        var returnFiber = sourceFiber.return
        if (returnFiber === null) {
          didFatal = true
          onUncaughtError(thrownValue)
        } else {
          throwException(
            root,
            returnFiber,
            sourceFiber,
            thrownValue,
            nextRenderExpirationTime,
          )
          nextUnitOfWork = completeUnitOfWork(sourceFiber)
          continue
        }
      }
    }
    break
  } while (true)

  logRootTimes(1, root)

  if (enableSchedulerTracing) {
    // Traced work is done for now; restore the previous interactions.
    tracing.__interactionsRef.current = prevInteractions
  }

  // We're done performing work. Time to clean up.
  isWorking = false
  ReactCurrentOwner$2.currentDispatcher = null
  resetContextDependences()

  // Yield back to main thread.
  if (didFatal) {
    var _didCompleteRoot = false
    stopWorkLoopTimer(interruptedBy, _didCompleteRoot)
    interruptedBy = null
    // There was a fatal error.
    {
      resetStackAfterFatalErrorInDev()
    }
    nextRoot = null
    onFatal(root)
    return
  }

  if (nextUnitOfWork !== null) {
    var _didCompleteRoot2 = false
    stopWorkLoopTimer(interruptedBy, _didCompleteRoot2)
    interruptedBy = null
    onYield(root)
    return
  }

  // We completed the whole tree.
  var didCompleteRoot = true
  stopWorkLoopTimer(interruptedBy, didCompleteRoot)
  var rootWorkInProgress = root.current.alternate
  !(rootWorkInProgress !== null)
    ? invariant(
        false,
        'Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue.',
      )
    : void 0

  nextRoot = null
  interruptedBy = null

  if (nextRenderDidError) {
    if (hasLowerPriorityWork(root, expirationTime)) {
      markSuspendedPriorityLevel(root, expirationTime)
      var suspendedExpirationTime = expirationTime
      var rootExpirationTime = root.expirationTime
      onSuspend(
        root,
        rootWorkInProgress,
        suspendedExpirationTime,
        rootExpirationTime,
        -1, // Indicates no timeout
      )
      return
    } else if (!root.didError && !isExpired) {
      root.didError = true
      var _suspendedExpirationTime = (root.nextExpirationTimeToWorkOn = expirationTime)
      var _rootExpirationTime = (root.expirationTime = Sync)
      onSuspend(
        root,
        rootWorkInProgress,
        _suspendedExpirationTime,
        _rootExpirationTime,
        -1, // Indicates no timeout
      )
      return
    }
  }

  if (!isExpired && nextLatestAbsoluteTimeoutMs !== -1) {
    // The tree was suspended.
    var _suspendedExpirationTime2 = expirationTime
    markSuspendedPriorityLevel(root, _suspendedExpirationTime2)

    var earliestExpirationTime = findEarliestOutstandingPriorityLevel(
      root,
      expirationTime,
    )
    var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime)
    if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
      nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs
    }

    var currentTimeMs = expirationTimeToMs(requestCurrentTime())
    var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs
    msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout

    // TODO: Account for the Just Noticeable Difference

    var _rootExpirationTime2 = root.expirationTime
    onSuspend(
      root,
      rootWorkInProgress,
      _suspendedExpirationTime2,
      _rootExpirationTime2,
      msUntilTimeout,
    )
    logRootTimes(2, root)
    return
  }

  logRootTimes(3, root)

  // Ready to commit.
  onComplete(root, rootWorkInProgress, expirationTime)
}