startPos = 0;
            endPos = stack.size();
        } else {
            // When analysing a problem stack trace, consider only the deepest user code in the stack.
            startPos = failure.indexOfStackFrame(0, StackFramePredicate.USER_CODE);
            if (startPos == -1) {
                // No user code in the stack
                return null;

// ExprString returns a string representation of x.
func ExprString(x syntax.Node) string { return syntax.String(x) }

// startPos returns the start position of node n.
func startPos(n syntax.Node) syntax.Pos { return syntax.StartPos(n) }

// endPos returns the position of the first character immediately after node n.
func endPos(n syntax.Node) syntax.Pos { return syntax.EndPos(n) }

				o.runes = append(o.runes, runes[prevI:i])
				o.directions = append(o.directions, prevDir)
				o.startpos = append(o.startpos, prevI)
			}
			prevI = i
			prevDir = curDir
		}
	}
	o.runes = append(o.runes, runes[prevI:])
	o.directions = append(o.directions, prevDir)
	o.startpos = append(o.startpos, prevI)
	return o
}

// Order computes the visual ordering of all the runs in a Paragraph.

            return
        }
        int startPos = 0
        int endPos = findEndIndexOfCurrentBuild(out, startPos)
        while (startPos < out.length()) {
            if (endPos == -1) {
                endPos = out.length()
            }
            results << createExecutionResult(out.substring(startPos, endPos), err)
            startPos = endPos
            endPos = findEndIndexOfCurrentBuild(out, startPos)

		if err != nil {
			t.Errorf("%s: %v", src, err)
			continue
		}

		// locate KeyValueExpr
		Inspect(f, func(n Node) bool {
			_, ok := n.(*KeyValueExpr)
			if ok {
				if got := StartPos(n).Col(); got != want {
					t.Errorf("%s: got col = %d, want %d", src, got, want)
				}
			}
			return !ok
		})
	}

            encoder.flush();
            long length = encoder.getWritePosition() - startPos;
            return new BlockAddress(id, startPos + startOffset, length);
        }

        @Override
        public void close() throws IOException {
            encoder.flush();
            outputStream.close();
        }

// argErrPos returns positioner for reporting an invalid argument count.
func argErrPos(call *ast.CallExpr) positioner { return inNode(call, call.Rparen) }

// startPos returns the start position of node n.
func startPos(n ast.Node) token.Pos { return n.Pos() }

// endPos returns the position of the first character immediately after node n.
func endPos(n ast.Node) token.Pos { return n.End() }

package syntax

// StartPos returns the start position of n.
func StartPos(n Node) Pos {
	// Cases for nodes which don't need a correction are commented out.
	for m := n; ; {
		switch n := m.(type) {
		case nil:
			panic("nil node")

		// packages
		case *File:
			// file block starts at the beginning of the file
			return MakePos(n.Pos().Base(), 1, 1)

	if ctxt.DebugInfo != nil {
		scopes, inlcalls = ctxt.DebugInfo(s, info, curfn)
	}
	var err error
	dwctxt := dwCtxt{ctxt}
	startPos := ctxt.InnermostPos(textPos(s))
	if !startPos.IsKnown() || startPos.RelLine() != uint(s.Func().StartLine) {
		panic("bad startPos")
	}
	fnstate := &dwarf.FnState{
		Name:          s.Name,
		Info:          info,
		Loc:           loc,
		Ranges:        ranges,

        final int startPos = prefix.length();
        for (final JarEntry entry : iterable(jarFile.entries())) {
            final String entryName = entry.getName().replace('\\', '/');
            if (entryName.startsWith(prefix) && entryName.endsWith(CLASS_SUFFIX)) {
                final String className = entryName.substring(startPos, entryName.length() - CLASS_SUFFIX.length()).replace('/', '.');