if (entries.size() > maxBlockEntries) {
                FreeListBlock newBlock = new FreeListBlock();
                newBlock.largestInNextBlock = largestInNextBlock;
                newBlock.nextBlock = nextBlock;
                newBlock.prev = this;
                newBlock.next = next;
                next = newBlock;

                List<FreeListEntry> newBlockEntries = entries.subList(0, entries.size() / 2);

					// the new blocks to be re-examined.
					d = f.NewBlock(BlockPlain)
					d.Pos = p.Pos
					blocks[argID] = d
					if f.pass.debug > 0 {
						f.Warnl(p.Pos, "split critical edge")
					}
				} else {
					reusedBlock = true
				}
			} else {
				// no existing block, so allocate a new block
				// to place on the edge
				d = f.NewBlock(BlockPlain)
				d.Pos = p.Pos
				if f.pass.debug > 0 {

            {{/* instructions for this source line */ -}}
            <span class=asm>{{"" -}}
            {{range .Instructions -}}
              {{/* separate when we hit a new basic block */ -}}
              {{if .NewBlock -}}{{printf " %8s %28s\n" "" "⋮"}}{{end -}}

              {{/* inlined calls leading to this instruction */ -}}
              {{range .InlinedCalls -}}
                {{printf " %8s %10s %10s %8s  " "" "" "" "" -}}

// CallExpr beneath an ExprStmt.
func New(body *ast.BlockStmt, mayReturn func(*ast.CallExpr) bool) *CFG {
	b := builder{
		mayReturn: mayReturn,
		cfg:       new(CFG),
	}
	b.current = b.newBlock(KindBody, body)
	b.stmt(body)

	// Compute liveness (reachability from entry point), breadth-first.
	q := make([]*Block, 0, len(b.cfg.Blocks))
	q = append(q, b.cfg.Blocks[0]) // entry point
	for len(q) > 0 {

    @Override
    void withoutLock(ResourceLock lock, Runnable action) {
        action.run()
    }

    @Override
    <T> T withReplacedLocks(Collection<? extends ResourceLock> currentLocks, ResourceLock newLock, Factory<T> factory) {
        return factory.create()
    }

    @Override
    <T> T whileDisallowingProjectLockChanges(Factory<T> action) {
        return action.create()
    }

    @Override

     */
    <T> T withReplacedLocks(Collection<? extends ResourceLock> currentLocks, ResourceLock newLock, Factory<T> factory);

    /**
     * Runs a given {@link Factory} while the specified locks are released and then reacquire the locks