protected T getResults() {
        return results;
    }

    protected abstract void renderBreadcrumbs(SimpleHtmlWriter htmlWriter) throws IOException;

    protected abstract void registerTabs();

    @Override
    protected URL getStyleUrl() {
        return STYLE_URL;
    }

    protected void addTab(String title, final Action<SimpleHtmlWriter> contentRenderer) {

            htmlWriter.endElement();
        }
        htmlWriter.endElement();
    }

    @Override
    protected void registerTabs() {
        addFailuresTab();
        addIgnoredTab();
        addTab("Classes", new ErroringAction<SimpleHtmlWriter>() {
            @Override

import org.gradle.internal.html.SimpleHtmlWriter;

import java.io.IOException;

class OverviewPageRenderer extends PageRenderer<AllTestResults> {

    @Override
    protected void registerTabs() {
        addFailuresTab();
        addIgnoredTab();
        if (!getResults().getPackages().isEmpty()) {
            addTab("Packages", new ErroringAction<SimpleHtmlWriter>() {
                @Override

                }
                codePanelRenderer.render(message, htmlWriter);
            }
            htmlWriter.endElement();
        }
    }

    @Override
    protected void registerTabs() {
        addFailuresTab();
        addTab("Tests", new ErroringAction<SimpleHtmlWriter>() {
            @Override
            public void doExecute(SimpleHtmlWriter writer) throws IOException {

        }
      }
    });
  }
}

}  // namespace

std::unique_ptr<Pass> CreateOrderByDialectPass() {
  return std::make_unique<OrderByDialectPass>();
}

void RegisterOrderByDialectPass() { registerPass(CreateOrderByDialectPass); }

}  // namespace TF

  });
}

std::unique_ptr<Pass> CreateGroupByDialectPass() {
  return std::make_unique<GroupByDialectPass>();
}

void RegisterGroupByDialectPass() { registerPass(CreateGroupByDialectPass); }

}  // namespace TF

tensorflow::CreateTensorFlowGraphOptimizationPass(
    const std::vector<std::string>& pass_names) {
  return std::make_unique<GraphOptByNamePass>(pass_names);
}

void tensorflow::RegisterGraphOptimizationPasses() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return std::make_unique<GraphOptByNamePass>();
  });

    }
  }
};

std::unique_ptr<Pass> CreateLowerGlobalsToMlProgramPass() {
  return std::make_unique<LowerGlobalsToMlProgram>();
}

void RegisterLowerGlobalsToMlProgramPass() {
  registerPass(CreateLowerGlobalsToMlProgramPass);
}

}  // namespace tf_saved_model