files map[string]*fileInfo
}

type fileInfo struct {
	file     *token.File
	lastline int
}

const maxlines = 64 * 1024

func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
	// TODO(mdempsky): Make use of column.

	// Since we don't know the set of needed file positions, we reserve
	// maxlines positions per file. We delay calling token.File.SetLines until

void SourceCode::IncreaseIndent() { current_indent_++; }

void SourceCode::DecreaseIndent() { current_indent_--; }

void SourceCode::ValidateAndAddLine(int indent, const string& raw_line) {
  StringPiece line(raw_line);
  bool had_trailing_newline = str_util::ConsumeSuffix(&line, "\n");

  if (absl::StrContains(line, '\n')) {
    LOG(ERROR) << "Attempt to add multiple lines; bad formatting is likely.";

  // CHECK-SAME: _xla_outside_compilation
  "tf_device.cluster"() ({
    %elem_shape = "tf.Const"() {value = dense<> : tensor<0xi32>} : () -> tensor<0xi32>
    %max_size = "tf.Const"() {value = dense<10> : tensor<i32>} : () -> tensor<i32>
    %1 = "tf.EmptyTensorList"(%elem_shape, %max_size) : (tensor<0xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<f32>>>

			match  string
			frames []frame
		}
		// mainLine is the line number of `func main()` in testprog/stacks.go.
		const mainLine = 21
		want := []evDesc{
			{trace.EventStateTransition, "Goroutine Running->Runnable", []frame{
				{"main.main", mainLine + 82},
			}},
			{trace.EventStateTransition, "Goroutine NotExist->Runnable", []frame{
				{"main.main", mainLine + 11},
			}},

     * Returns the tail of a file.
     *
     * @param file to read from tail
     * @param maxLines max lines to read
     * @return tail content
     * @throws org.gradle.util.GFileUtils.TailReadingException when reading failed
     */
    @SuppressWarnings("DefaultCharset")
    public static String tail(File file, int maxLines) throws TailReadingException {
        logDeprecation();
        BufferedReader reader = null;

  auto get_value_at = [](ArrayRef<T> v, size_t i) -> T {
    if (v.size() == 1) return v.front();
    return v[i];
  };

  size_t max_size = std::max(a.size(), b.size());
  SmallVector<T> result(max_size);
  for (size_t i : llvm::seq<size_t>(0, max_size)) {
    result[i] = get_value_at(a, i) * get_value_at(b, i);
  }
  return result;
}

        final String keyProp = NAME_PREFIX + id;
        requestBody.put(KEY_PROPERTY, keyProp);
        requestBody.put(KEY_PROPERTY, keyProp);
        requestBody.put("query", "query" + id);
        requestBody.put("max_size", new Integer(id).toString());
        requestBody.put("boost", 100);
        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {

            private static final int MAX_LEN = 1000;

            private final ByteArrayOutputStream buf = new ByteArrayOutputStream(MAX_LEN);

            @Override
            public void write(final int b) throws IOException {
                if (b == '\n' || b == '\r' || buf.size() >= MAX_LEN) {
                    try {

        return true;
      }
    }
  }

  @Override
  public int size() {
    return size;
  }

  // We're careful to put only E instances into the array in the mainline.
  // (In the backport, we don't need this suppression, but we keep it to minimize diffs.)
  @SuppressWarnings("unchecked")
  @Override
  public UnmodifiableIterator<E> iterator() {
    return asList().iterator();
  }

}

LogicalResult CreateInitBufferValue(ArrayRef<int64_t> element_shape,
                                    Value max_size, Operation* op,
                                    Type element_dtype, OpBuilder builder,
                                    Value* buffer) {
  auto max_count_op = max_size.getDefiningOp();
  if (!max_count_op) return op->emitOpError("unknown max element count");