}
        }

        @Override
        public Boundary getUpperBoundary() {
            org.eclipse.aether.version.VersionRange.Bound bound = delegate.getUpperBound();
            if (bound == null) {
                return null;
            }
            return new Boundary() {
                @Override
                public Version getVersion() {

	PosDefaultStmt uint = iota // Default; position is not a statement boundary, but might be if optimization removes the designated statement boundary
	PosIsStmt                  // Position is a statement boundary; if optimization removes the corresponding instruction, it should attempt to find a new instruction to be the boundary.

			}
			return j
		}
		return i
	}
	return i
}

// notStmtBoundary reports whether a value with opcode op can never be a statement
// boundary. Such values don't correspond to a user's understanding of a
// statement boundary.
func notStmtBoundary(op Op) bool {
	switch op {
	case OpCopy, OpPhi, OpVarDef, OpVarLive, OpUnknown, OpFwdRef, OpArg, OpArgIntReg, OpArgFloatReg:
		return true
	}
	return false

L1:--e89a8ff1c1e83553e304be640612
L2:Content-Type: multipart/alternative; boundary=e89a8ff1c1e83553e004be640610
L3:
L4:--e89a8ff1c1e83553e004be640610
L5:Content-Type: text/plain; charset=UTF-8
L6:
L7:*body*
L8:
L9:--e89a8ff1c1e83553e004be640610
L10:Content-Type: text/html; charset=UTF-8
L11:
L12:<b>body</b>
L13:
L14:--e89a8ff1c1e83553e004be640610--
L15:--e89a8ff1c1e83553e304be640612
L16:Content-Type: image/png; name="x.png"
L17:Content-Disposition: attachment; 
L18:	filename="x.png"
...

 * which is triggered by {@code enterDynamicCall} and {@code leaveDynamicCall}.
 * <p>
 * An entry point is a boundary between non-dynamic code and a dynamic lookup. For example,
 * one such boundary is {@code Project.hasProperty}. The object used for entry point is checked
 * for equality with the argument passed to {@code leaveDynamicCall}.
 * <p>

	MaximumWorkingSetSize   uintptr
	ActiveProcessLimit      uint32
	Affinity                uintptr
	PriorityClass           uint32
	SchedulingClass         uint32
	_                       uint32 // pad to 8 byte boundary

	var op EmptyOp = EmptyNoWordBoundary
	var boundary byte
	switch {
	case IsWordChar(r1):
		boundary = 1
	case r1 == '\n':
		op |= EmptyBeginLine
	case r1 < 0:
		op |= EmptyBeginText | EmptyBeginLine
	}
	switch {
	case IsWordChar(r2):
		boundary ^= 1
	case r2 == '\n':
		op |= EmptyEndLine
	case r2 < 0:
		op |= EmptyEndText | EmptyEndLine
	}
	if boundary != 0 { // IsWordChar(r1) != IsWordChar(r2)

		y = 49
	case 8:
		y = 64
	default:
		panic("too large")
	}

	// check PC is in the same function
	runtime.Callers(1, pc1[:])
	if pc1[0] < pc0[0] || pc1[0] > pc0[0]+1000000 {
		fmt.Printf("jump across DSO boundary. pc0=%x, pc1=%x\n", pc0[0], pc1[0])
		panic("FAIL")
	}

	if y != x*x {
		fmt.Printf("x=%d y=%d!=%d\n", x, y, x*x)
		panic("FAIL")
	}

# dependency: omitting vendored dependencies and stopping at the 'cmd' module
# boundary.

go list $GOROOT/src/...
stdout ^bytes$
! stdout ^builtin$
! stdout ^cmd/
! stdout ^vendor/
! stdout ^golang\.org/x/


# Vendored dependencies should appear with their 'vendor/' paths in std (they're
# in GOROOT/src, but not in the 'std' module following the usual module-boundary
# rules).

cd $GOROOT/src
env GOWORK=off

go list std

	MaximumWorkingSetSize   uintptr
	ActiveProcessLimit      uint32
	Affinity                uintptr
	PriorityClass           uint32
	SchedulingClass         uint32
	_                       uint32 // pad to 8 byte boundary