}

    return quant::stablehlo::ImportedMlirModuleOp(std::move(module), nullptr);
  }

  std::unordered_set<std::string> tag_set(tag_names.begin(), tag_names.end());
  return quant::stablehlo::SavedModelToMlirModuleOp(
      input_path, tag_set, exported_model_signatures, *context);
}

// Convert an TF module to a StableHLO module
absl::StatusOr<OwningOpRef<ModuleOp>> ConvertTFToStablehlo(

    bool show_debug_info, TF_Status* status) {
  // Load the saved model into a SavedModelBundle.

  std::unordered_set<string> tag_set =
      absl::StrSplit(tags, ',', absl::SkipEmpty());

  tensorflow::SavedModelBundle bundle;
  auto load_status =
      tensorflow::LoadSavedModel({}, {}, saved_model_path, tag_set, &bundle);
  if (!load_status.ok()) {
    tsl::Set_TF_Status_from_Status(status, load_status);
    return "// error";
  }

    return nullptr;
  }

  std::unordered_set<string> tag_set;
  for (int i = 0; i < tags_len; i++) {
    tag_set.insert(string(tags[i]));
  }

  tensorflow::SavedModelBundle bundle;
  status->status =
      tensorflow::LoadSavedModel(session_options->options, run_options_proto,
                                 export_dir, tag_set, &bundle);
  if (!status->status.ok()) return nullptr;

package org.gradle.junitplatform;

import org.junit.jupiter.api.*;

public class TagTest {
    @Fast
    @Test
    public void fastTest() {
    }

    @Tag("slow")
    @Test
    public void slowTest(){
    }

package org.gradle.junitplatform;

import org.junit.jupiter.api.*;

public class TagTest {
    @Fast
    @Test
    public void fastTest() {
    }

    @Tag("slow")
    @Test
    public void slowTest(){
    }

John Howard <******@****.***> 1700260866 -0800

  }

  @Override
  public NavigableSet<E> tailSet(@ParametricNullness E fromElement, boolean inclusive) {
    return delegate().tailSet(fromElement, inclusive);
  }

  /**
   * A sensible definition of {@link #tailSet(Object)} in terms of the {@link #tailSet(Object,
   * boolean)} method. If you override {@link #tailSet(Object, boolean)}, you may wish to override
   * {@link #tailSet(Object)} to forward to this implementation.
   */

    }

    public String toString(Tag[] tags) {
        return toString(tags[0]);
    }

    public static void register(Map tagletMap) {
        LocaleAwareTaglet taglet = new LocaleAwareTaglet();
        tagletMap.put(taglet.getName(), taglet);
    }

                                         TF_Status* status) {
  std::string saved_model_dir(dirname);

  std::unordered_set<std::string> tagset;
  for (int i = 0; i < tags_len; ++i) {
    tagset.insert(std::string(tags[i]));
  }

  std::unique_ptr<tensorflow::SavedModelAPI> result;
  if (tensorflow::unwrap(ctx)->UsesTFRT()) {
    status->status = tensorflow::errors::Unimplemented(

    return delegate().subSet(fromElement, toElement);
  }

  @Override
  public SortedSet<E> tailSet(@ParametricNullness E fromElement) {
    return delegate().tailSet(fromElement);
  }

  /**
   * A sensible definition of {@link #contains} in terms of the {@code first()} method of {@link
   * #tailSet}. If you override {@link #tailSet}, you may wish to override {@link #contains} to
   * forward to this implementation.
   *