/*parallel_iterations=*/10,
        /*is_stateless=*/false, /*shape_invariant=*/false);
    new_while.getCond().takeBody(while_op.getCond());
    new_while.getBody().takeBody(while_op.getBody());
    ReplaceReturnOp(new_while.getCond(), rewriter);
    ReplaceReturnOp(new_while.getBody(), rewriter);
    rewriter.replaceOp(while_op, new_while.getResults());
    return success();
  }

            'dependencies {'
        }

        @Override
        public String getEnd() {
            '}'
        }
    },
    API {
        @Override
        public String getBegin() {
            'api { dependencies {'
        }

        @Override
        public String getEnd() {
            '}}'
        }
    },
    SOURCES {
        @Override

  return type && type.getRank() == rank &&
         mlir::isa<FloatType>(type.getElementType());
}

// Returns true if the given `value` has the specified rank or has unranked
// type.
inline bool IsOfRankOrUnranked(Value value, int64_t rank) {
  RankedTensorType type = GetRankedTensorTypeForOperand(value);
  return !type || type.getRank() == rank;
}

    ShapedType& updates_type, ConversionPatternRewriter& rewriter) {
  auto canonical_update_window_dims = llvm::to_vector(
      llvm::seq<int64_t>(indices_type.getRank() - 1, updates_type.getRank()));

  if (canonical_update_window_dims == update_window_dims) return success();

  // Permute updates if `update_window_dims` are leading indices.

  auto num_loop_carried = while_op.getCond().getNumArguments();
  auto not_carried_operands =
      while_op.getOperands().drop_front(num_loop_carried);
  extern_values.insert(not_carried_operands.begin(),
                       not_carried_operands.end());
  auto old_extern_values_size = extern_values.size();

  llvm::SmallVector<Region*, 2> regions{&while_op.getCond(),

        return callableInfo.getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.CALLER_CLASS_NAME);
    }

    public static boolean hasInjectVisitorContext(CallableInfo callableInfo) {
        return callableInfo.getParameters().stream().anyMatch(it -> it.getKind() == ParameterKindInfo.INJECT_VISITOR_CONTEXT);
    }

        return symbol;
    }

    private static boolean isPackageInfoFile(TaskEvent e, File asSourceFile) {
        return e.getKind() == TaskEvent.Kind.ANALYZE && "package-info.java".equals(asSourceFile.getName());
    }

    private static boolean isClassGenerationPhase(TaskEvent e) {
        return e.getKind() == TaskEvent.Kind.GENERATE;
    }

    public void registerMapping(String key, String symbol) {

  auto operand_shape = builder.create<TFL::ShapeOp>(
      RankedTensorType::get(static_cast<int32_t>(operand_type.getRank()),
                            builder.getIntegerType(32)),
      operand);
  const int64_t operand_rank = operand_type.getRank();
  // Compute flattened out dimension and contracting dimension using
  // TFL::UnsortedSegmentProdOp.

        Optional<ParameterInfo> varargParameter = callable.getParameters().stream().filter(it -> it.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER).findAny();
        CallableKindInfo kind = callable.getKind();
        return Stream.of(
            // Match the `Class<?>` in `receiver` for static methods and constructors
            kind == STATIC_METHOD || kind == AFTER_CONSTRUCTOR

  if (!output_type) return failure();

  // bias should be a vector sized of the last output dim.
  int64_t num_units = output_type.getDimSize(output_type.getRank() - 1);
  auto bias_type =
      mlir::RankedTensorType::get({num_units}, output_type.getElementType());

  mlir::DenseElementsAttr bias_attr;
  if (output_type.getElementType().isF32()) {
    float val = 0.0;