resolvedOrRejected(id, rejector, result)
                return
            }

            def resolved = findDynamicVersion(acceptor, rejector)
            if (resolved) {
                def id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(moduleId.group, moduleId.name), resolved as String)

      enable_soft_placement,  set_original_tf_func_name};

  auto module_or = tensorflow::GraphdefToMlirTranslateFunction(
      input, input_arrays, input_dtypes, input_shapes, output_arrays,
      control_output_arrays, options, context);
  if (!module_or.status().ok()) return nullptr;
  return std::move(module_or).value();
}

static TranslateToMLIRRegistration GraphdefToMlirTranslate(

  mlir::MLIRContext context(registry);
  auto module_or = ConvertSavedModelToMlir(
      &bundle, &context, absl::Span<std::string>(exported_names));
  if (!module_or.status().ok()) {
    tsl::Set_TF_Status_from_Status(status, module_or.status());
    return "// error";
  }

  return MlirModuleToString(*std::move(module_or).value(), show_debug_info);
}

            if (includeLast) {
                sb.append(" --> ");
                SelectorState selector = edge.getSelector();
                ModuleIdentifier moduleId = selector.getTargetModule().getId();
                sb.append('\'').append(moduleId.getGroup()).append(':').append(moduleId.getName()).append('\'');
                if (variantDetails != null) {
                    sb.append(variantDetails);
                }
            }

            return null;
        }

        @Override
        public boolean participatesInReplacements(ModuleIdentifier moduleId) {
            return false;
        }
    };

    @Nullable Replacement getReplacementFor(ModuleIdentifier sourceModule);

    boolean participatesInReplacements(ModuleIdentifier moduleId);

    class Replacement {
        private final ModuleIdentifier target;
        private final String reason;

  }
  auto module_out = std::move(module_or_status).value();

  // We cannot replace the module in a ModulePass. So we simply copy the
  // operation list from module_out to module_in.
  auto& module_in_ops = module_in.getBody()->getOperations();
  module_in_ops.clear();
  module_in_ops.splice(module_in_ops.end(),
                       module_out->getBody()->getOperations());
}

        }

        @Override
        public void onChangingModuleResolve(ModuleComponentIdentifier moduleId, Expiry expiry) {
        }
    };

    /**
     * Called when a dynamic version is selected using the set of candidate versions queried from a repository.
     */

  if (saved_model_version == 2) {
    auto module_or = SavedModelObjectGraphToMlirImport(
        input_filename, tags, exported_names, context,
        /*unconditionally_use_set_output_shapes=*/true);
    if (!module_or.status().ok()) return module_or.status();
    return std::move(module_or).value();
  } else if (saved_model_version == 1) {
    MLIRImportOptions options;

 * limitations under the License.
 */

package org.gradle.test.fixtures.ivy

import org.apache.ivy.core.IvyPatternHelper
import org.apache.ivy.core.module.id.ModuleId
import org.apache.ivy.core.module.id.ModuleRevisionId

class M2CompatibleIvyPatternHelper {

    static String substitute(String pattern, String organisation, String module, String revision, boolean m2Compatible) {

            ModuleComponentSelector requested = dependency.getSelector();
            final ModuleIdentifier moduleId = requested.getModuleIdentifier();
            ModuleVersionsCache.CachedModuleVersionList cachedModuleVersionList = moduleVersionsCache.getCachedModuleResolution(delegate, moduleId);
            if (cachedModuleVersionList != null) {
                Set<String> versionList = cachedModuleVersionList.getModuleVersions();