p.closeLabelScope()
	p.closeScope()
	rbrace := p.expect(token.RBRACE)

	return &ast.BlockStmt{lbrace, list, rbrace}
}

func (p *parser) parseBlockStmt() *ast.BlockStmt {
	if p.trace {
		defer un(trace(p, "BlockStmt"))
	}

	lbrace := p.expect(token.LBRACE)
	p.openScope()
	list := p.parseStmtList()
	p.closeScope()
	rbrace := p.expect(token.RBRACE)

	return &ast.BlockStmt{lbrace, list, rbrace}

	"cmd/internal/telemetry"
	"flag"
	"fmt"
	"internal/trace"
	"internal/trace/raw"
	"internal/trace/traceviewer"
	"io"
	"log"
	"net"
	"net/http"
	_ "net/http/pprof" // Required to use pprof
	"os"
	"sync/atomic"
	"time"
)

const usageMessage = "" +
	`Usage of 'go tool trace':
Given a trace file produced by 'go test':
	go test -trace=trace.out pkg

Open a web browser displaying trace:

					// strings were generated by
					// runtime/trace.TestUserTaskRegion, which is the basis for
					// the user_task_region_* test cases. We only check for the
					// Go 1.21 traces because earlier traces used different
					// strings.
					switch ev.Kind() {
					case trace.EventRegionBegin, trace.EventRegionEnd:
						if _, ok := validRegions[ev.Region().Type]; !ok {

		}
		os.Exit(0)
	}

	t.Parallel()

	// Look for strace in /bin or /usr/bin. Don't assume that some
	// strace on PATH is the one that we want.
	strace := "/bin/strace"
	if _, err := os.Stat(strace); err != nil {
		strace = "/usr/bin/strace"
		if _, err := os.Stat(strace); err != nil {
			t.Skipf("skipping test because strace not found: %v", err)
		}
	}

	exe, err := os.Executable()
	if err != nil {

type Type uint8

// Spec is a specification for a trace event. It contains sufficient information
// to perform basic parsing of any trace event for any version of Go.
type Spec struct {
	// Name is the human-readable name of the trace event.
	Name string

	// Args contains the names of each trace event's argument.
	// Its length determines the number of arguments an event has.
	//

			log.Printf("failed to generate trace: %v", err)
		}
	})
}

// traceContext is a wrapper around a traceviewer.Emitter with some additional
// information that's useful to most parts of trace viewer JSON emission.
type traceContext struct {
	*traceviewer.Emitter
	startTime trace.Time
	endTime   trace.Time
}

// elapsed returns the elapsed time between the trace time and the start time
// of the trace.

type regionFingerprint struct {
	Frame trace.StackFrame
	Type  string
}

func fingerprintRegion(r *trace.UserRegionSummary) regionFingerprint {
	return regionFingerprint{
		Frame: regionTopStackFrame(r),
		Type:  r.Name,
	}
}

func regionTopStackFrame(r *trace.UserRegionSummary) trace.StackFrame {
	var frame trace.StackFrame
	if r.Start != nil && r.Start.Stack() != trace.NoStack {

            if (trace.getData() instanceof CollectStepData) {
                collectStepTrace = (CollectStepData) trace.getData();
                break;
            }
            trace = trace.getParent();
        }
        return collectStepTrace;
    }

    /**
     * The event "artifact resolved" if fired WHENEVER an artifact is resolved, BUT it happens also when an artifact

/*
Trace is a tool for viewing trace files.

Trace files can be generated with:
  - runtime/trace.Start
  - net/http/pprof package
  - go test -trace

Example usage:
Generate a trace file with 'go test':

	go test -trace trace.out pkg

View the trace in a web browser:

	go tool trace trace.out

Generate a pprof-like profile from the trace:

	b0.Event("ProcStart", trace.ProcID(1), testgen.Seq(1))
	b0.Event("GoSyscallEndBlocked")

	// A running goroutine stole P0 at the generation boundary.
	b1 := g.Batch(trace.ThreadID(1), 0)
	b1.Event("ProcStatus", trace.ProcID(2), go122.ProcRunning)
	b1.Event("GoStatus", trace.GoID(2), trace.ThreadID(1), go122.GoRunning)
	b1.Event("ProcStatus", trace.ProcID(0), go122.ProcSyscallAbandoned)