public void cancel() {
        List<Runnable> toCall = new ArrayList<Runnable>();
        synchronized (lock) {
            if (cancelled) {
                return;
            }
            cancelled = true;
            toCall.addAll(callbacks);
            callbacks.clear();
        }

        List<Throwable> failures = new ArrayList<Throwable>();
        for (Runnable callback : toCall) {
            try {

			src = strings.Replace(src, "TWOS", "2"+strings.Repeat(", 2", i-1), -1)
			fmt.Print(src)
			tocall = append(tocall, fmt.Sprintf("CheckEq%d_%s", i, strings.Title(typ)))
		}
	}
	fmt.Println("func main() {")
	for _, fun := range tocall {
		fmt.Printf("\t%s()\n", fun)
		fmt.Printf("\t%sExtraVar()\n", fun)
	}
	fmt.Println("}")

		return n

	case ir.OAS,
		ir.OASOP,
		ir.OAS2,
		ir.OAS2DOTTYPE,
		ir.OAS2RECV,
		ir.OAS2FUNC,
		ir.OAS2MAPR,
		ir.OCLEAR,
		ir.OCLOSE,
		ir.OCOPY,
		ir.OCALLINTER,
		ir.OCALL,
		ir.OCALLFUNC,
		ir.ODELETE,
		ir.OSEND,
		ir.OPRINT,
		ir.OPRINTLN,
		ir.OPANIC,
		ir.ORECOVERFP,
		ir.OGETG:
		if n.Typecheck() == 0 {
			base.Fatalf("missing typecheck: %+v", n)
		}

	OADDSTR:           "+",
	OANDAND:           "&&",
	OANDNOT:           "&^",
	OAND:              "&",
	OAPPEND:           "append",
	OAS:               "=",
	OAS2:              "=",
	OBREAK:            "break",
	OCALL:             "function call", // not actual syntax
	OCAP:              "cap",
	OCASE:             "case",
	OCLEAR:            "clear",
	OCLOSE:            "close",
	OCOMPLEX:          "complex",
	OBITNOT:           "^",

  """Substitutes the for loop templates in the given module."""
  compiled_regex = re.compile(
      r'^\s*for\s(.*?)\sin\s(\[.*?\])\s\{(.*?)\}\s//\send\sfor\n',
      re.MULTILINE | re.DOTALL)
  while True:
    func_match = re.search(compiled_regex, module)
    if func_match is None:
      break

    try:
      arg_name = func_match.group(1)
      arg_values = ast.literal_eval(func_match.group(2))

func (b *Builder) BuildFromAndTo(fromAll echo.Callers, toAll echo.Services) *Builder {
	b.t.Helper()
	out := b.Copy()

	systemNS := istio.ClaimSystemNamespaceOrFail(out.t, out.t)

	for _, from := range fromAll {
		for _, to := range toAll {
			for _, s := range out.needFromAndTo {
				out.addYAML(withParams(s, param.Params{

)

// TODO(mdempsky): Investigate replacing with switch statements or dense arrays.

var branchOps = [...]ir.Op{
	syntax.Break:       ir.OBREAK,
	syntax.Continue:    ir.OCONTINUE,
	syntax.Fallthrough: ir.OFALL,
	syntax.Goto:        ir.OGOTO,
}

var callOps = [...]ir.Op{
	syntax.Defer: ir.ODEFER,
	syntax.Go:    ir.OGO,

                Pattern.MULTILINE + Pattern.DOTALL);
        Matcher matcher = pattern.matcher(source);

        if (matcher.matches()) {
            String uid = matcher.group(1) == null ? null : matcher.group(1).substring("uid=".length());

// license that can be found in the LICENSE file.

// Test functions and goroutines.

package main

func caller(f func(int, int) int, a, b int, c chan int) {
	c <- f(a, b)
}

func gocall(f func(int, int) int, a, b int) int {
	c := make(chan int)
	go caller(f, a, b, c)
	return <-c
}

func call(f func(int, int) int, a, b int) int {
	return f(a, b)
}

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"reflect"
)

type G[T any] interface {
	g() func()(*T)
}
type Foo[T any] struct {

}
// OCALL
func (l *Foo[T]) f1() (*T) {
	return g[T]()()
}
// OCALLFUNC
func (l *Foo[T]) f2() (*T) {
	var f = g[T]
	return f()()
}
// OCALLMETH
func (l *Foo[T]) f3() (*T) {
	return l.g()()
}
// OCALLINTER