becomes

	{
		var #next int
		var #state1 = abi.RF_READY
		f(func() { // 1,2
			if #state1 != abi.RF_READY { runtime.panicrangestate(#state1) }
			#state1 = abi.RF_PANIC
			var #state2 = abi.RF_READY
			g(func() { // 3,4
				if #state2 != abi.RF_READY { runtime.panicrangestate(#state2) }
				#state2 = abi.RF_PANIC
				var #state3 = abi.RF_READY
				h(func() { // 5,6

func state1(s *scanner, c byte) int {
	if '0' <= c && c <= '9' {
		s.step = state1
		return scanContinue
	}
	return state0(s, c)
}

// state0 is the state after reading `0` during a number.
func state0(s *scanner, c byte) int {
	if c == '.' {
		s.step = stateDot
		return scanContinue
	}
	if c == 'e' || c == 'E' {
		s.step = stateE
		return scanContinue
	}

	SetResizeStatus(PodResizeStatus) error
	Delete(podUID string, containerName string) error
	ClearState() error
}

// State interface provides methods for tracking and setting pod resource allocation
type State interface {
	Reader
	writer

}

// Chdir changes the State's working directory to the given path.
func (s *State) Chdir(path string) error {
	dir := s.Path(path)
	if _, err := os.Stat(dir); err != nil {
		return &fs.PathError{Op: "Chdir", Path: dir, Err: err}
	}
	s.pwd = dir
	s.Setenv("PWD", dir)
	return nil
}

// Context returns the Context with which the State was created.
func (s *State) Context() context.Context {
	return s.ctx

See the License for the specific language governing permissions and
limitations under the License.
*/

package state

import (
	"k8s.io/utils/cpuset"
)

// ContainerCPUAssignments type used in cpu manager state
type ContainerCPUAssignments map[string]map[string]cpuset.CPUSet

// Clone returns a copy of ContainerCPUAssignments

                        assertTrue state1.hasMutableState()
                        assertTrue state2.hasMutableState()
                    }
                    state1.applyToMutableState {
                        assertTrue state1.hasMutableState()
                        assertTrue state2.hasMutableState()
                    }
                    assert state1.hasMutableState()
                    assert state2.hasMutableState()

			delete(fractions, staleReporter)
		}
		c.CurrentState[key] = fractions
	}
}

func (c *Controller) queueWriteStatus(config status.Resource, state Progress) {
	c.workers.EnqueueStatusUpdateResource(state, config)
}

func (c *Controller) configDeleted(res config.Config) {
	r := status.ResourceFromModelConfig(res)
	c.workers.Delete(r)
}

func boolToConditionStatus(b bool) string {
	if b {
		return "True"

    def state1 = Mock(ChangeContainer)
    def state2 = Mock(ChangeContainer)
    def state = new SummarizingChangeContainer(state1, state2)
    def visitor = new CollectingChangeVisitor()

    def "looks for changes in all delegate change sets"() {
        when:
        state.accept(visitor)

        then:
        1 * state1.accept(_) >> true
        1 * state2.accept(_) >> true
        0 * _

The build state is managed by the `BuildState` class.
An instance is created for each build in the build definition, once per build execution and is discarded at the end of the execution. 

The build state also includes what is currently called the "Gradle state". The Gradle state is being merged into the build state and is mostly empty.

### Project state

// further events will be processed. This method may leave the gState in
// an inconsistent state.
func (gs *gState[R]) finish(ctx *traceContext) {
	if gs.executing != R(noResource) {
		gs.syscallEnd(ctx.endTime, false, ctx)
		gs.stop(ctx.endTime, trace.NoStack, ctx)
	}
}

// rangeBegin indicates the start of a special range of time.
func (gs *gState[R]) rangeBegin(ts trace.Time, name string, stack trace.Stack) {