"printer":                              "\U0001f5a8\ufe0f",
	"probing_cane":                         "\U0001f9af",
	"puerto_rico":                          "\U0001f1f5\U0001f1f7",
	"punch":                                "\U0001f44a",
	"purple_circle":                        "\U0001f7e3",
	"purple_heart":                         "\U0001f49c",
	"purple_square":                        "\U0001f7ea",

	`[:graph:]`:   {+1, code10},
	`[:^graph:]`:  {-1, code10},
	`[:lower:]`:   {+1, code11},
	`[:^lower:]`:  {-1, code11},
	`[:print:]`:   {+1, code12},
	`[:^print:]`:  {-1, code12},
	`[:punct:]`:   {+1, code13},
	`[:^punct:]`:  {-1, code13},
	`[:space:]`:   {+1, code14},
	`[:^space:]`:  {-1, code14},
	`[:upper:]`:   {+1, code15},
	`[:^upper:]`:  {-1, code15},
	`[:word:]`:    {+1, code16},
	`[:^word:]`:   {-1, code16},

		`[[:punct:]]pod(?P<poduid>[[:xdigit:]]{8}[[:punct:]]?[[:xdigit:]]{4}[[:punct:]]?[[:xdigit:]]{4}[[:punct:]]?[[:xdigit:]]{4}[[:punct:]]?[[:xdigit:]]{12})[[:punct:]]` +
		// zero or more punctuation separated "segments" (e.g. "docker-")
		`(?:[[:^punct:]]+[[:punct:]])*` +
		// non-punctuation end of string, i.e., the container ID
		`(?P<containerid>[[:^punct:]]+)$`),

      buffer.put(readBuffer);
      munchIfFull();
      return this;
    }

    // First add just enough to fill buffer size, and munch that
    int bytesToCopy = bufferSize - buffer.position();
    for (int i = 0; i < bytesToCopy; i++) {
      buffer.put(readBuffer.get());
    }
    munch(); // buffer becomes empty here, since chunkSize divides bufferSize

    // Now process directly from the rest of the input buffer

      buffer.put(readBuffer);
      munchIfFull();
      return this;
    }

    // First add just enough to fill buffer size, and munch that
    int bytesToCopy = bufferSize - buffer.position();
    for (int i = 0; i < bytesToCopy; i++) {
      buffer.put(readBuffer.get());
    }
    munch(); // buffer becomes empty here, since chunkSize divides bufferSize

    // Now process directly from the rest of the input buffer

		b.addMappingEntry(0, 0, 0, "", "", true)
		// TODO(hyangah): make addMapping return *memMap or
		// take a memMap struct, and get rid of addMappingEntry
		// that takes a bunch of positional arguments.
	}
}

func readMainModuleMapping() (start, end uint64, exe, buildID string, err error) {
	return 0, 0, "", "", errors.New("not implemented")

};

// Unroll split into a bunch of slice ops.
struct UnrollSplit : public OpRewritePattern<TFL::SplitOp> {
  using OpRewritePattern<TFL::SplitOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(TFL::SplitOp split_op,
                                PatternRewriter& rewriter) const override;
};

// Unroll splitv into a bunch of slice ops.
struct UnrollSplitV : public OpRewritePattern<TFL::SplitVOp> {

//export go_callback2
func go_callback2() {
	runtime.GC()
}

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

	// Do a whole bunch of cgocallbacks.
	const n = 10
	done := make(chan bool)
	for i := 0; i < n; i++ {
		go func() {
			C.foo()
			done <- true
		}()
	}
	for i := 0; i < n; i++ {
		<-done
	}

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

package endpoint

import "encoding/json"

// Mirror types from grpc to avoid pulling in a bunch of deps

const FileWatcherCertProviderName = "file_watcher"

type FileWatcherCertProviderConfig struct {
	CertificateFile   string          `json:"certificate_file,omitempty"`

#include <pthread.h>
#include <sched.h>

struct cgoTracebackArg {
	uintptr_t  context;
	uintptr_t  sigContext;
	uintptr_t* buf;
	uintptr_t  max;
};

static int raceprofCount;

// We want a bunch of different profile stacks that collide in the
// hash table maintained in runtime/cpuprof.go. This code knows the
// size of the hash table (1 << 10) and knows that the hash function
// is simply multiplicative.