* @see AggregatingProcessor
 */
class AggregatingProcessingStrategy extends IncrementalProcessingStrategy {

    AggregatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);
        result.setType(AGGREGATING);
    }

    @Override
    public void recordProcessingInputs(Set<String> supportedAnnotationTypes, Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        validateAnnotations(annotations);

  auto cast_op =
      OpBuilder(old_val.getDefiningOp())
          .create<tensor::CastOp>(old_val.getLoc(), old_val.getType(), new_val);
  old_val.replaceAllUsesWith(cast_op);
}

void ReplaceAllUsesExceptTerminator(Value old_val, Value new_val) {
  if (old_val.getType() == new_val.getType()) {
    old_val.replaceAllUsesWith(new_val);
    return;
  }
  Operation* old_op = old_val.getDefiningOp();

          block.getArgument(it.first->getSecond()));
    }
    var_handle_op.erase();
  }

  if (!var_handle_shared_names->empty())
    function.setType(FunctionType::get(function.getContext(), func_arg_types,
                                       func_type.getResults()));

  return success();
}

// Records the current live value for a resource variable and whether a read or

	ifs := ctxt.loader.LookupOrCreateSym("go:link.addmoduledata", 0)
	initfunc := ctxt.loader.MakeSymbolUpdater(ifs)
	ctxt.loader.SetAttrReachable(ifs, true)
	ctxt.loader.SetAttrLocal(ifs, true)
	initfunc.SetType(sym.STEXT)

	// Add the init func and/or addmoduledata to Textp.
	if ctxt.BuildMode == BuildModePlugin {
		ctxt.Textp = append(ctxt.Textp, amd)
	}
	ctxt.Textp = append(ctxt.Textp, initfunc.Sym())

    SmallVector<Value> new_float_func_args{func_args.begin(), func_args.end()};
    new_float_func_args[weight_operand_idx] = reshape_op;
    new_float_func.getArgument(weight_operand_idx).setType(new_shape);
    new_float_func.setType(FunctionType::get(
        getContext(), TypeRange{ValueRange{new_float_func_args}},
        new_float_func.getResultTypes()));
    symbol_table.insert(new_float_func);

            op->getLoc(),
            CloneTypeWithNewElementType(input.getType(), rewriter.getF32Type()),
            input);
        op->setOperand(i, f32_cast);
      }
    }

    // Casts BF16 outputs of the operation.
    for (Value value : op->getResults()) {
      if (getElementTypeOrSelf(value).isBF16()) {
        value.setType(CloneTypeWithNewElementType(value.getType(),

    }

    private static TransferEvent event(
            RepositorySystemSession session, TransferResource resource, TransferEvent.EventType type) {
        return new TransferEvent.Builder(session, resource).setType(type).build();
    }

  permutation_op.getOperation()->moveBefore(&op->getBlock()->front());

  // Bypass Transpose nodes for all results.
  for (OpResult result : op->getResults()) {
    result.setType(
        cast<TransposeOp>(*result.getUsers().begin()).getY().getType());
    for (Operation* transpose : result.getUsers()) {
      transpose->getResult(0).replaceAllUsesWith(result);
    }
  }

                           std::vector<std::string> &result,
                           InputDataType act_type, const bool per_axis,
                           const bool is_toco) {
  std::list<std::string> required_types = {
      GetTypeToStringRepresentation().at("F32")};

  switch (act_type) {
    case InputDataType::INT8: {
      required_types.push_back(GetTypeToStringRepresentation().at("QI8"));
      break;

        mavenDependency.setGroupId(dependency.getGroupId());
        mavenDependency.setArtifactId(dependency.getArtifactId());
        mavenDependency.setVersion(dependency.getVersion());
        mavenDependency.setType(dependency.getType());
        mavenDependency.setScope(dependency.getScope());
        mavenDependency.setClassifier(dependency.getClassifier());
        if (dependency.isOptional()) {