MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<FoldTransposedConstantOp>(&ctx);
  if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {
    func_op.emitError("Failed to fold constant->transpose pattern.");
    signalPassFailure();
  }
}

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));
  for (auto func : module.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError()
          << "quant-lift-quantizable-spots-as-functions-drq failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>

    // island wraps a single op.
    Operation& wrapped_op = island.GetBody().front();
    TF::ParallelExecutionIdPairs id_pairs;
    if (failed(TF::ParseParallelExecutionIds(&wrapped_op, id_pairs))) {
      wrapped_op.emitError()
          << "Malformed " << TF::kParallelExecAnnotation << " attribute";
      return failure();
    }
    if (id_pairs.empty()) continue;

    TF::ParallelIdsMap& ids_map = op_to_parallel_ids_map[island];

  // parallel.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-quantize-weights failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateQuantizeWeightsPass(

    if (exportedNames.empty()) {
      name = "global_ml_" + globalTensor.getSymName().str();
    } else if (exportedNames.size() == 1) {
      name = exportedNames[0].str();
    } else {
      return globalTensor.emitError()
             << "Multiple exported names for global tensor not supported yet";
    }
    Attribute initial_value;
    if (globalTensor.getValue()) {
      initial_value = *globalTensor.getValue();
    } else {

      }
      if (!common_arg_index.has_value()) {
        common_arg_index = block_arg.getArgNumber();
      } else if (common_arg_index.value() != block_arg.getArgNumber()) {
        return op->emitError("result #")
               << result_idx
               << " is not tied to the same argument across all branches";
      }
    }

    if (io_match && result_idx != common_arg_index.value()) {

  // Iterate over the sorted list of functions to keep order deterministic.
  for (func::FuncOp func : GetSortedFunctions(module_op)) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError()
          << "quant-stablehlo-lift-quantizable-spots-as-functions failed.";
      signalPassFailure();
    }
  }

  // Remove all attr_map attributes.

  std::string bytecode;
  llvm::raw_string_ostream os(bytecode);
  if (mlir::failed(stablehlo::serializePortableArtifact(
          stablehlo_module, stablehlo::getCurrentVersion(), os))) {
    return stablehlo_module.emitError()
           << "failed to serialize the pruned stablehlo module";
  }
  return bytecode;
}

// Serializes the stablehlo functions called by XlaCallModuleOp to bytecode

    return IsControlFlowV1Op(op) ? mlir::WalkResult::interrupt()
                                 : mlir::WalkResult::advance();
  });
  if (result.wasInterrupted()) {
    mlir::TFL::AttachErrorCode(
        module.emitError(
            "The graph has Control Flow V1 ops. TFLite converter doesn't "
            "support Control Flow V1 ops. Consider using Control Flow V2 ops "

        auto error_msg =
            "'main' FuncOp in XlaCallModuleOp missing or has visibility other "
            "than 'public'";
        if (main_func_op) {
          main_func_op->emitError(error_msg);
        }
        return rewriter.notifyMatchFailure(op, error_msg);
      }
    }
    Builder stablehlo_builder(stablehlo_module_op.get().getContext());