}

	n := len(prog.Inst)
	i := 0
	for matchSize[i] != 0 && matchSize[i] < n {
		i++
	}
	regexp.mpool = i

	return regexp, nil
}

// Pools of *machine for use during (*Regexp).doExecute,
// split up by the size of the execution queues.
// matchPool[i] machines have queue size matchSize[i].
// On a 64-bit system each queue entry is 16 bytes,
// so matchPool[0] has 16*2*128 = 4kB queues, etc.

            legacySupport.setSession(session);

            return doExecute(request, session, result, chainedWorkspaceReader);
        } finally {
            sessionScope.exit();
        }
    }

    private MavenExecutionResult doExecute(
            MavenExecutionRequest request,
            MavenSession session,
            MavenExecutionResult result,

    @Override
    protected void registerTabs() {
        addFailuresTab();
        addIgnoredTab();
        addTab("Classes", new ErroringAction<SimpleHtmlWriter>() {
            @Override
            public void doExecute(SimpleHtmlWriter htmlWriter) throws IOException {
                renderClasses(htmlWriter);
            }
        });
    }

        IoActions.withResource(ImplementationDependencyRelocator.class.getResourceAsStream(type.getIdentifier() + "-relocated.txt"), new ErroringAction<InputStream>() {
            @Override
            protected void doExecute(InputStream thing) throws Exception {
                BufferedReader reader = new BufferedReader(new InputStreamReader(thing, Charset.forName("UTF-8")));
                String line;

        try {
            IoActions.withResource(new FileOutputStream(probeFile), new ErroringAction<FileOutputStream>() {
                @Override
                protected void doExecute(FileOutputStream thing) throws Exception {
                    thing.write(probeClass.get());
                }
            });
        } catch (FileNotFoundException e) {

        }

        try {
            IoActions.withResource(outStr, new ErroringAction<OutputStream>() {
                @Override
                protected void doExecute(final OutputStream outStr) throws Exception {
                    TarArchiveOutputStream tarOutStr;
                    try {
                        tarOutStr = new TarArchiveOutputStream(outStr);

        try (ProjectLock lock = new ProjectLock(session, mojoDescriptor)) {
            doExecute2(session, mojoExecution);
        } finally {
            for (MavenProject forkedProject : forkedProjects) {
                forkedProject.setExecutionProject(null);
            }
        }
    }

    private void doExecute2(MavenSession session, MojoExecution mojoExecution) throws LifecycleExecutionException {

    static void writeClassesInZipFileToTextFile(File zipFile, File txtFile) {
        IoActions.withResource(new ZipInputStream(new FileInputStream(zipFile)), new ErroringAction<ZipInputStream>() {
            protected void doExecute(ZipInputStream inputStream) throws Exception {
                ZipEntry zipEntry = inputStream.getNextEntry()
                while (zipEntry != null) {
                    String name = zipEntry.name

        }

        @Override
        public void execute(Task task) {
            if (application == null) {
                doExecute(task);
            } else {
                application.reapply(() -> doExecute(task));
            }
        }

        private void doExecute(Task task) {
            closure.setDelegate(task);
            closure.setResolveStrategy(Closure.DELEGATE_FIRST);

     */
    public ExpectedRequest head(String path) {
        return new ExpectMethodAndRunAction("HEAD", normalizePath(path), new ErroringAction<HttpExchange>() {
            @Override
            protected void doExecute(HttpExchange exchange) throws Exception {
                exchange.sendResponseHeaders(200, -1);
            }
        });
    }

    /**