TFL::CustomOp tfl_custom_op =
          BuildCustomOp(composite, custom_option_buffer);
      composite->replaceAllUsesWith(tfl_custom_op);
      composite->erase();
    });
  }
};

static PassRegistration<LegalizeCompositeToCustomOpPass> pass;

}  // namespace odml

// Creates an instance of the TensorFlow dialect to QuantOps dialect pass.
std::unique_ptr<OperationPass<func::FuncOp>> CreateLegalizeTFToQuantPass() {
  return std::make_unique<LegalizeTFToQuant>();
}

static PassRegistration<LegalizeTFToQuant> pass([] {
  return CreateLegalizeTFToQuantPass();
});

}  // namespace TF

  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateTacFilterPass(
    TacFilters* tac_filters) {
  return std::make_unique<TacFilterPass>(tac_filters);
}

static PassRegistration<TacFilterPass> pass;

}  // namespace tac
}  // namespace TFL

// Creates an instance of `AddQuantizationUnitLocPass`.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateAddQuantizationUnitLocPass() {
  return std::make_unique<AddQuantizationUnitLocPass>();
}

static PassRegistration<AddQuantizationUnitLocPass> pass;

}  // namespace quant

  }
}

}  // end namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateTransposeCommuteOpsPass() {
  return std::make_unique<TransposeCommuteOpsPass>();
}

static PassRegistration<TransposeCommuteOpsPass> pass;

}  // end namespace odml

  for (auto func_op : module_op.getOps<func::FuncOp>()) {
    if (failed(LiftHashTableOpsToArguments(module_op, func_op))) {
      signalPassFailure();
      return;
    }
  }
}

static PassRegistration<LiftHashTableOpsAsArgsPass> pass;

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateLiftHashTableOpsAsArgsPass() {
  return std::make_unique<LiftHashTableOpsAsArgsPass>();
}

  }

  auto it = function_library_map.find(op_set);
  if (it != function_library_map.end()) {
    return it->second;
  }
  return llvm::StringRef();
}

static PassRegistration<InsertQuantizedFunctionsPass> pass;

void InsertQuantizedFunctionsPass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTable symbol_table(module);

  }
}
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreatePinOpsWithSideEffectsPass() {
  return std::make_unique<PinOpsWithSideEffectsPass>();
}

static PassRegistration<PinOpsWithSideEffectsPass> pass;

}  // namespace TFL

    LOG(INFO) << "There are no VarHandleOps to save. SaveV2 op will not "
                 "be created.";
    return;
  }

  CreateSaveFunc(module_op, target_var_handle_ops);
}

static PassRegistration<InsertSaveOpPass> pass{};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateInsertSaveOpPass() {
  return std::make_unique<InsertSaveOpPass>();
}

}  // namespace quant

}
}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizeBatchMatmulPass() {
  return std::make_unique<OptimizeBatchMatmulPass>();
}

static PassRegistration<OptimizeBatchMatmulPass> pass;

}  // namespace TFL