// is a linux kernel, relocationSymbol is the name of the symbol
	// corresponding to the start address.
	Open(file string, start, limit, offset uint64, relocationSymbol string) (ObjFile, error)

	// Disasm disassembles the named object file, starting at
	// the start address and stopping at (before) the end address.
	Disasm(file string, start, end uint64, intelSyntax bool) ([]Inst, error)
}

	}

	return &taskFilter{name: strings.Join(name, ","), cond: conditions}, nil
}

func taskInterval(t *parsedTrace, s *trace.UserTaskSummary) interval {
	var i interval
	if s.Start != nil {
		i.start = s.Start.Time()
	} else {
		i.start = t.startTime()
	}
	if s.End != nil {
		i.end = s.End.Time()
	} else {
		i.end = t.endTime()
	}
	return i
}

// R5 length of a
// R7 length of b
// R4 points to the start of a
// R6 points to the start of b
// R13 points to the return value (-1/0/1)
TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0
	BEQ	R4, R6, samebytes // same start of a and b

	SGTU	R5, R7, R9
	BNE	R0, R9, r2_lt_r1
	MOVV	R5, R14
	JMP	entry
r2_lt_r1:
	MOVV	R7, R14	// R14 is min(R4, R5)
entry:
	ADDV	R4, R14, R12	// R6 start of a, R14 end of a
	BEQ	R4, R12, samebytes // length is 0

	defer cancel()

	// Create a pre-existing region. This won't end up in the trace.
	preExistingRegion := trace.StartRegion(bgctx, "pre-existing region")

	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

	// Beginning of traced execution.
	var wg sync.WaitGroup
	ctx, task := trace.NewTask(bgctx, "task0") // EvUserTaskCreate("task0")

// See the License for the specific language governing permissions and
// limitations under the License.

[[quick_start]]
= Gradle Quick Start

== Installing Gradle

Most projects will start with an existing Gradle build which does not require the installation of Gradle.

        } else {
            System.setProperty("java.util.logging.config.class", savedJULConfigClassProperty)
        }
    }

    def "start and stop do nothing when nothing is redirected"() {
        when:
        redirector.start()
        [Level.SEVERE, Level.WARNING, Level.INFO, Level.CONFIG, Level.FINE, Level.FINER, Level.FINEST].each {
            logger1.log(it, "Test");

        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)
        def text = "some text"
        def bytes = text.bytes

        when:
        async {
            start {
                def b1 = stream.read()
                assert b1 == bytes[0]
                def b2 = stream.read()
                assert b2 == bytes[1]
            }
            thread.blockUntil.requested

}

// UnmarshalXML decodes a single XML element into a DelMarkerExpiration value
func (de *DelMarkerExpiration) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) error {
	type delMarkerExpiration DelMarkerExpiration
	var dexp delMarkerExpiration
	err := dec.DecodeElement(&dexp, &start)
	if err != nil {
		return err
	}

	if dexp.Days <= 0 {
		return errInvalidDaysDelMarkerExpiration
	}

						d = 1
					}
					del := p.Text[0] == '~'
					x := &Emph{Marker: p.Text[:d], Inner: append([]Inline(nil), dst[start.i+1:]...)}
					start.Text = start.Text[:len(start.Text)-d]
					p.Text = p.Text[d:]
					if start.Text == "" {
						dst = dst[:start.i]
					} else {
						dst = dst[:start.i+1]
					}
					trimStack()
					if del {
						dst = append(dst, (*Del)(x))
					} else if d == 2 {

	start := ^uintptr(0)
	end := uintptr(0)
	if start > firstmoduledata.noptrdata {
		start = firstmoduledata.noptrdata
	}
	if start > firstmoduledata.data {
		start = firstmoduledata.data
	}
	if start > firstmoduledata.noptrbss {
		start = firstmoduledata.noptrbss
	}
	if start > firstmoduledata.bss {
		start = firstmoduledata.bss
	}