[]string{"", "c"},

		// Positive or negative.
		[]string{"", "n"},

		// Size of index.
		[]string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"},
	}

	forall(choices, func(x []string) {
		p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6]

		// Pass: dynamic=0, static=1, 2.
		// Which cases should be caught statically?
		// Only constants, obviously.

scala/collection/TraversableLike$$anonfun$forall$1$$anonfun$apply$mcV$sp$2.class package scala.collection; public final synchronized class TraversableLike$$anonfun$forall$1$$anonfun$apply$mcV$sp$2 extends scala.runtime.AbstractFunction1 implements scala.Serializable { public void TraversableLike$$anonfun$forall$1$$anonfun$apply$mcV$sp$2(TraversableLike$$anonfun$forall$1); } scala/collection/TraversableLike$$anonfun$flatMap$1.class package scala.collection; public final synchronized class TraversableLike$$anonfun$flatMap$1...

	"𝔉":                             "\U0001d509",
	"◼":               "\u25fc",
	"▪":           "\u25aa",
	"𝔽":                            "\U0001d53d",
	"∀":                          "\u2200",
	"ℱ":                      "\u2131",
	"ℱ":                            "\u2131",
	"Ѓ":                            "\u0403",

		"Ffr;":                             '\U0001D509',
		"FilledSmallSquare;":               '\U000025FC',
		"FilledVerySmallSquare;":           '\U000025AA',
		"Fopf;":                            '\U0001D53D',
		"ForAll;":                          '\U00002200',
		"Fouriertrf;":                      '\U00002131',
		"Fscr;":                            '\U00002131',
		"GJcy;":                            '\U00000403',

};

// Represents an uninterpreted symbol in a logical predicate.
//
// Two predicates are equivalent iff they are equivalent for all assignments to
// the symbols contained in them, i.e. predicates are forall qualified over
// symbols.
class SymbolPredicate : public Predicate {
 public:
  explicit SymbolPredicate(int64_t id, TensorId tensor_id, bool must_be_true)
      : Predicate(id),

        entities.put("lArr", "\u21d0");
        entities.put("uArr", "\u21d1");
        entities.put("rArr", "\u21d2");
        entities.put("dArr", "\u21d3");
        entities.put("hArr", "\u21d4");
        entities.put("forall", "\u2200");
        entities.put("part", "\u2202");
        entities.put("exist", "\u2203");
        entities.put("empty", "\u2205");
        entities.put("nabla", "\u2207");
        entities.put("isin", "\u2208");

        entities.put("lArr", "\u21d0");
        entities.put("uArr", "\u21d1");
        entities.put("rArr", "\u21d2");
        entities.put("dArr", "\u21d3");
        entities.put("hArr", "\u21d4");
        entities.put("forall", "\u2200");
        entities.put("part", "\u2202");
        entities.put("exist", "\u2203");
        entities.put("empty", "\u2205");
        entities.put("nabla", "\u2207");
        entities.put("isin", "\u2208");

	"darr":     "\u2193",
	"harr":     "\u2194",
	"crarr":    "\u21B5",
	"lArr":     "\u21D0",
	"uArr":     "\u21D1",
	"rArr":     "\u21D2",
	"dArr":     "\u21D3",
	"hArr":     "\u21D4",
	"forall":   "\u2200",
	"part":     "\u2202",
	"exist":    "\u2203",
	"empty":    "\u2205",
	"nabla":    "\u2207",
	"isin":     "\u2208",
	"notin":    "\u2209",
	"ni":       "\u220B",
	"prod":     "\u220F",

			}))
		}
	}

	return out
}

// BuildAll builds the config for all sources.
func (b *Builder) BuildAll(fromAll echo.Callers, toAll echo.Services) *Builder {
	b.t.Helper()

	return b.BuildCompleteSources().
		BuildFrom(fromAll...).
		BuildFromAndTo(fromAll, toAll)
}

func (b *Builder) Apply(opts ...apply.Option) {
	if b.yamlCount == 0 {
		// Nothing to do.
		return
	}

	}
	in.macros[name] = &Macro{
		name:   name,
		args:   args,
		tokens: tokens,
	}
}

// macroDefinition returns the list of formals and the tokens of the definition.
// The argument list is nil for no parens on the definition; otherwise a list of
// formal argument names.
func (in *Input) macroDefinition(name string) ([]string, []Token) {
	prevCol := in.Stack.Col()
	tok := in.Stack.Next()