// Includes
#include<stdlib.h>

#define SIZE(X) (assert((X).size() < (1LL<<(sizeof(long long int)*8-2))), static_cast<long long int>((X).size()))
#include<assert.h>

#include<iostream>
using std::istream;
using std::ostream;
using std::iostream;
using std::cin;
using std::cout;
using std::cerr;

#include<cstring>
#include<string>
using std::string;

#include<cstdlib>

#define CHECK_TRACE_CONTENTS(...)  check_trace_contents(__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)

#include<vector>
using std::vector;
#include<list>
using std::list;
#include<map>
using std::map;
#include<set>
using std::set;
#include<algorithm>

#include<iostream>
using std::istream;
using std::ostream;
using std::cin;
using std::cout;
using std::cerr;
#include<iomanip>

#include<sstream>
using std::istringstream;
using std::ostringstream;

#include<fstream>
using std::ifstream;
using std::ofstream;

#include"termbox/termbox.h"

#define unused  __attribute__((unused))

#include<utility>
using std::pair;
#include<math.h>

#include<dirent.h>
#include<sys/stat.h>


#include <stack>
using std::stack;

using std::min;
using std::max;

using std::abs;

#include<math.h>

// End Includes

// Types
// Mu types encode how the numbers stored in different parts of memory are
// interpreted. A location tagged as a 'character' type will interpret the
// value 97 as the letter 'a', while a different location of type 'number'
// would not.
//
// Unlike most computers today, mu stores types in a single big table, shared
// by all the mu programs on the computer. This is useful in providing a
// seamless experience to help understand arbitrary mu programs.
typedef long long int type_ordinal;
typedef long long int recipe_ordinal;

typedef void (*test_fn)(void);

struct trace_line {
  int depth;  // optional field just to help browse traces later
  string label;
  string contents;
  trace_line(string l, string c) :depth(0), label(l), contents(c) {}
  trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {}
};

struct end {};
// Recipes are lists of instructions. To perform or 'run' a recipe, the
// computer runs its instructions.
// Each instruction is either of the form:
//   product1, product2, product3, ... <- operation ingredient1, ingredient2, ingredient3, ...
// or just a single 'label' starting with a non-alphanumeric character
//   +label
// Labels don't do anything, they're just waypoints.
// Ingredients and products are a single species -- a reagent. Reagents refer
// either to numbers or to locations in memory along with 'type' tags telling
// us how to interpret them. They also can contain arbitrary other lists of
// properties besides types, but we're getting ahead of ourselves.
struct property {
  vector<string> values;
};

// Types can range from a simple type ordinal, to arbitrarily complex trees of
// type parameters, like (map (address array character) (list number))
struct type_tree {
  string name;
  type_ordinal value;
  type_tree* left;
  type_tree* right;
  ~type_tree();
  type_tree(const type_tree& old);
  // simple: type ordinal
  explicit type_tree(string name, type_ordinal v) :name(name), value(v), left(NULL), right(NULL) {}
  // intermediate: list of type ordinals
  type_tree(string name, type_ordinal v, type_tree* r) :name(name), value(v), left(NULL), right(r) {}
  // advanced: tree containing type ordinals
  type_tree(type_tree* l, type_tree* r) :value(0), left(l), right(r) {}
};

struct string_tree {
  string value;
  string_tree* left;
  string_tree* right;
  ~string_tree();
  string_tree(const string_tree& old);
  // simple: flat string
  explicit string_tree(string v) :value(v), left(NULL), right(NULL) {}
  // intermediate: list of strings
  string_tree(string v, string_tree* r) :value(v), left(NULL), right(r) {}
  // advanced: tree containing strings
  string_tree(string_tree* l, string_tree* r) :left(l), right(r) {}
};

struct reagent {
  string original_string;
  string name;
  type_tree* type;
  vector<pair<string, string_tree*> > properties;
  double value;
  bool initialized;
  reagent(string s);
  reagent() :type(NULL), value(0), initialized(false) {}
  ~reagent();
  void clear();
  reagent(const reagent& old);
  reagent& operator=(const reagent& old);
  void set_value(double v) { value = v; initialized = true; }
};

struct instruction {
  bool is_label;
  string label;  // only if is_label
  string name;  // only if !is_label
  string old_name;  // before our automatic rewrite rules
  string original_string;
  recipe_ordinal operation;  // get(Recipe_ordinal, name)
  vector<reagent> ingredients;  // only if !is_label
  vector<reagent> products;  // only if !is_label
  mutable bool tangle_done;
  // End instruction Fields
  instruction();
  void clear();
  bool is_empty();
};

struct recipe {
  string name;
  vector<instruction> steps;
  long long int transformed_until;
  bool has_header;
  vector<reagent> ingredients;
  vector<reagent> products;
  map<string, int> ingredient_index;

  string original_name;
  // End recipe Fields
  recipe();
};

// You can construct arbitrary new types. New types are either 'containers'
// with multiple 'elements' of other types, or 'exclusive containers' containing
// one of multiple 'variants'. (These are similar to C structs and unions,
// respectively, though exclusive containers implicitly include a tag element
// recording which variant they should be interpreted as.)
//
// For example, storing bank balance and name for an account might require a
// container, but if bank accounts may be either for individuals or groups,
// with different properties for each, that may require an exclusive container
// whose variants are individual-account and joint-account containers.
enum kind_of_type {
  PRIMITIVE,
  CONTAINER,
  EXCLUSIVE_CONTAINER
};

struct type_info {
  string name;
  kind_of_type kind;
  long long int size;  // only if type is not primitive; primitives and addresses have size 1 (except arrays are dynamic)
  vector<reagent> elements;
  map<string, type_ordinal> type_ingredient_names;


  // End type_info Fields
  type_info() :kind(PRIMITIVE), size(0) {}
};

enum primitive_recipes {
  IDLE = 0,
  COPY,
  ADD,
  SUBTRACT,
  MULTIPLY,
  DIVIDE,
  DIVIDE_WITH_REMAINDER,
  SHIFT_LEFT,
  SHIFT_RIGHT,
  AND_BITS,
  OR_BITS,
  XOR_BITS,
  FLIP_BITS,
  AND,
  OR,
  NOT,
  JUMP,
  JUMP_IF,
  JUMP_UNLESS,
  EQUAL,
  GREATER_THAN,
  LESSER_THAN,
  GREATER_OR_EQUAL,
  LESSER_OR_EQUAL,
  TRACE,
  STASH,
  HIDE_ERRORS,
  SHOW_ERRORS,
  TRACE_UNTIL,
  _DUMP_TRACE,
  _CLEAR_TRACE,
  _SAVE_TRACE,
  ASSERT,
  _PRINT,
  _EXIT,
  _SYSTEM,
  _DUMP_MEMORY,
  _LOG,
  GET,
  GET_ADDRESS,
  MERGE,
  _DUMP,
  _FOO,
  CREATE_ARRAY,
  INDEX,
  INDEX_ADDRESS,
  LENGTH,
  MAYBE_CONVERT,
  NEXT_INGREDIENT,
  REWIND_INGREDIENTS,
  INGREDIENT,
  REPLY,
  NEW,
  ALLOCATE,
  ABANDON,
  TO_LOCATION_ARRAY,
  BREAK,
  BREAK_IF,
  BREAK_UNLESS,
  LOOP,
  LOOP_IF,
  LOOP_UNLESS,
  RUN,
  MEMORY_SHOULD_CONTAIN,
  TRACE_SHOULD_CONTAIN,
  TRACE_SHOULD_NOT_CONTAIN,
  CHECK_TRACE_COUNT_FOR_LABEL,
  NEXT_INGREDIENT_WITHOUT_TYPECHECKING,
  CALL,
  START_RUNNING,
  ROUTINE_STATE,
  RESTART,
  STOP,
  _DUMP_ROUTINES,
  LIMIT_TIME,
  WAIT_FOR_LOCATION,
  WAIT_FOR_ROUTINE,
  SWITCH,
  RANDOM,
  MAKE_RANDOM_NONDETERMINISTIC,
  ROUND,
  HASH,
  HASH_OLD,
  OPEN_CONSOLE,
  CLOSE_CONSOLE,
  CLEAR_DISPLAY,
  SYNC_DISPLAY,
  CLEAR_LINE_ON_DISPLAY,
  PRINT_CHARACTER_TO_DISPLAY,
  CURSOR_POSITION_ON_DISPLAY,
  MOVE_CURSOR_ON_DISPLAY,
  MOVE_CURSOR_DOWN_ON_DISPLAY,
  MOVE_CURSOR_UP_ON_DISPLAY,
  MOVE_CURSOR_RIGHT_ON_DISPLAY,
  MOVE_CURSOR_LEFT_ON_DISPLAY,
  DISPLAY_WIDTH,
  DISPLAY_HEIGHT,
  HIDE_CURSOR_ON_DISPLAY,
  SHOW_CURSOR_ON_DISPLAY,
  HIDE_DISPLAY,
  SHOW_DISPLAY,
  WAIT_FOR_SOME_INTERACTION,
  CHECK_FOR_INTERACTION,
  INTERACTIONS_LEFT,
  CLEAR_DISPLAY_FROM,
  SCREEN_SHOULD_CONTAIN,
  SCREEN_SHOULD_CONTAIN_IN_COLOR,
  _DUMP_SCREEN,
  ASSUME_CONSOLE,
  REPLACE_IN_CONSOLE,
  _BROWSE_TRACE,
  RUN_INTERACTIVE,
  _START_TRACKING_PRODUCTS,
  _STOP_TRACKING_PRODUCTS,
  _MOST_RECENT_PRODUCTS,
  SAVE_ERRORS_WARNINGS,
  SAVE_APP_TRACE,
  _CLEANUP_RUN_INTERACTIVE,
  RELOAD,
  RESTORE,
  SAVE,
  // End Primitive Recipe Declarations
  MAX_PRIMITIVE_RECIPES,
};
struct no_scientific {
  double x;
  explicit no_scientific(double y) :x(y) {}
};

typedef void (*transform_fn)(recipe_ordinal);

// Book-keeping while running a recipe.
// Everytime a recipe runs another, we interrupt it and start running the new
// recipe. When that finishes, we continue this one where we left off.
// This requires maintaining a 'stack' of interrupted recipes or 'calls'.
struct call {
  recipe_ordinal running_recipe;
  long long int running_step_index;
  vector<vector<double> > ingredient_atoms;
  vector<reagent> ingredients;
  long long int next_ingredient_to_process;
  long long int default_space;
  // End call Fields
  call(recipe_ordinal r) {
    running_recipe = r;
    running_step_index = 0;
    next_ingredient_to_process = 0;

    default_space = 0;

    // End call Constructor
  }
  ~call() {
    // End call Destructor
  }
};
typedef list<call> call_stack;

enum routine_state {
  RUNNING,
  COMPLETED,
  DISCONTINUED,
  WAITING,
  // End routine States
};
struct routine {
  call_stack calls;
  long long int alloc, alloc_max;
  long long int global_space;
  enum routine_state state;
  long long int id;
  // todo: really should be routine_id, but that's less efficient.
  long long int parent_index;  // only < 0 if there's no parent_index
  long long int limit;
  // only if state == WAITING
  long long int waiting_on_location;
  int old_value_of_waiting_location;
  // only if state == WAITING
  long long int waiting_on_routine;
  // End routine Fields
  routine(recipe_ordinal r);
  bool completed() const;
  const vector<instruction>& steps() const;
};

struct merge_check_point {
  reagent container;
  long long int container_element_index;
  merge_check_point(const reagent& c, long long int i) :container(c), container_element_index(i) {}
};

struct merge_check_state {
  stack<merge_check_point> data;
};

struct scenario {
  string name;
  string to_run;
};

// scan an array of characters in a unicode-aware, bounds-checked manner
struct raw_string_stream {
  long long int index;
  const long long int max;
  const char* buf;

  raw_string_stream(const string&);
  uint32_t get();  // unicode codepoint
  uint32_t peek();  // unicode codepoint
  bool at_end() const;
  void skip_whitespace_and_comments();
};

// End Types

// prototypes are auto-generated in the makefile; define your functions in any order
#include "function_list"  // by convention, files ending with '_list' are auto-generated

// from http://stackoverflow.com/questions/152643/idiomatic-c-for-reading-from-a-const-map
template<typename T> typename T::mapped_type& get(T& map, typename T::key_type const& key) {
  typename T::iterator iter(map.find(key));
  assert(iter != map.end());
  return iter->second;
}
template<typename T> typename T::mapped_type const& get(const T& map, typename T::key_type const& key) {
  typename T::const_iterator iter(map.find(key));
  assert(iter != map.end());
  return iter->second;
}
template<typename T> typename T::mapped_type const& put(T& map, typename T::key_type const& key, typename T::mapped_type const& value) {
  map[key] = value;
  return map[key];
}
template<typename T> bool contains_key(T& map, typename T::key_type const& key) {
  return map.find(key) != map.end();
}
template<typename T> typename T::mapped_type& get_or_insert(T& map, typename T::key_type const& key) {
  return map[key];
}
bool has_data(istream& in) {
  return in && !in.eof();
}

// Globals
const test_fn Tests[] = {
};

bool Run_tests = false;
bool Passed = true;  // set this to false inside any test to indicate failure
long Num_failures = 0;

#define CHECK(X) \
  if (!(X)) { \
    ++Num_failures; \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << '\n'; \
    Passed = false; \
    return;  /* Currently we stop at the very first failure. */ \
  }

#define CHECK_EQ(X, Y) \
  if ((X) != (Y)) { \
    ++Num_failures; \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << " == " << #Y << '\n'; \
    cerr << "  got " << (X) << '\n';  /* BEWARE: multiple eval */ \
    Passed = false; \
    return;  /* Currently we stop at the very first failure. */ \
  }

const int Max_depth = 9999;
const int Error_depth = 0;  // definitely always print the error that caused death
const int Warning_depth = 1;
const int App_depth = 2;  // temporarily where all mu code will trace to
const int Initial_callstack_depth = 101;
const int Max_callstack_depth = 9989;

map<recipe_ordinal, recipe> Recipe;
map<string, recipe_ordinal> Recipe_ordinal;
recipe_ordinal Next_recipe_ordinal = 1;

// Locations refer to a common 'memory'. Each location can store a number.
map<long long int, double> Memory;
map<string, type_ordinal> Type_ordinal;
map<type_ordinal, type_info> Type;
type_ordinal Next_type_ordinal = 1;
const string Ignore(",");  // commas are ignored in mu except within [] strings
// word boundaries
const string Terminators("(){}");
bool Disable_redefine_warnings = false;
vector<recipe_ordinal> Recently_added_recipes;
long long int Reserved_for_tests = 1000;
vector<transform_fn> Transform;

routine* Current_routine = NULL;
map<string, long long int> Instructions_running;
map<string, long long int> Locations_read;
map<string, long long int> Locations_read_by_instruction;

ofstream LOG;
vector<type_ordinal> Recently_added_types;
long long int foo = -1;
long long int Memory_allocated_until = Reserved_for_tests;
long long int Initial_memory_per_routine = 100000;
map<long long int, long long int> Free_list;
map<recipe_ordinal, map<string, long long int> > Name;
bool Warn_on_missing_default_space = false;
map<recipe_ordinal, recipe_ordinal> Surrounding_space;

vector<scenario> Scenarios;
set<string> Scenario_names;


long long int Num_core_mu_tests = 0;
const scenario* Current_scenario = NULL;
bool Scenario_testing_scenario = false;
map<string /*label*/, recipe> Before_fragments, After_fragments;
set<string /*label*/> Fragments_used;
bool Transform_check_insert_fragments_Ran = false;
map<string, vector<recipe_ordinal> > Recipe_variants;
set<string> Literal_type_names;
list<call> resolve_stack;

// We'll use large type ordinals to mean "the following type of the variable".
const int START_TYPE_INGREDIENTS = 2000;
vector<recipe_ordinal> Recently_added_shape_shifting_recipes;
vector<routine*> Routines;
long long int Current_routine_index = 0;
long long int Scheduling_interval = 500;
long long int Next_routine_id = 1;
long long int Display_row = 0, Display_column = 0;
bool Autodisplay = true;

// Scenarios may not define default-space, so they should fit within the
// initial area of memory reserved for tests. We'll put the predefined
// variables available to them at the end of that region.
const long long int Max_variables_in_scenarios = Reserved_for_tests-100;
long long int Next_predefined_global_for_scenarios = Max_variables_in_scenarios;
// Scenario Globals.
const long long int SCREEN = Next_predefined_global_for_scenarios++;
const long long int CONSOLE = Next_predefined_global_for_scenarios++;
// End Scenario Globals.
map<string, long long int> Key;
set<long long int> Visible;
long long int Top_of_screen = 0;
long long int Last_printed_row = 0;
map<int, long long int> Trace_index;  // screen row -> trace index

bool Track_most_recent_products = false;
string Most_recent_products;
// End Globals

bool Hide_errors = false;
bool Hide_warnings = false;
struct trace_stream {
  vector<trace_line> past_lines;
  // accumulator for current line
  ostringstream* curr_stream;
  string curr_label;
  int curr_depth;
  int callstack_depth;
  int collect_depth;
  ofstream null_stream;  // never opens a file, so writes silently fail
  trace_stream() :curr_stream(NULL), curr_depth(Max_depth), callstack_depth(0), collect_depth(Max_depth) {}
  ~trace_stream() { if (curr_stream) delete curr_stream; }

  ostream& stream(string label) {
    return stream(Max_depth, label);
  }

  ostream& stream(int depth, string label) {
    if (depth > collect_depth) return null_stream;
    curr_stream = new ostringstream;
    curr_label = label;
    curr_depth = depth;
    return *curr_stream;
  }

  // be sure to call this before messing with curr_stream or curr_label
  void newline() {
    if (!curr_stream) return;
    string curr_contents = curr_stream->str();
    if (curr_contents.empty()) return;
    past_lines.push_back(trace_line(curr_depth, trim(curr_label), curr_contents));  // preserve indent in contents
    if (!Hide_errors && curr_label == "error")
      cerr << curr_label << ": " << curr_contents << '\n';
    else if (!Hide_warnings && curr_label == "warn")
      cerr << curr_label << ": " << curr_contents << '\n';
    delete curr_stream;
    curr_stream = NULL;
    curr_label.clear();
    curr_depth = Max_depth;
  }

  // Useful for debugging.
  string readable_contents(string label) {  // missing label = everything
    ostringstream output;
    label = trim(label);
    for (vector<trace_line>::iterator p = past_lines.begin(); p != past_lines.end(); ++p)
      if (label.empty() || label == p->label) {
        output << std::setw(4) << p->depth << ' ' << p->label << ": " << p->contents << '\n';
      }
    return output.str();
  }
};



trace_stream* Trace_stream = NULL;

// Top-level helper. IMPORTANT: can't nest.
#define trace(...)  !Trace_stream ? cerr /*print nothing*/ : Trace_stream->stream(__VA_ARGS__)
#define raise  (!Trace_stream ? (tb_shutdown(),cerr) /*do print*/ : Trace_stream->stream(Warning_depth, "warn"))
#define raise_error  (!Trace_stream ? (tb_shutdown(),cerr) /*do print*/ : Trace_stream->stream(Error_depth, "error"))

ostream& operator<<(ostream& os, unused end) {
  if (Trace_stream && Trace_stream->curr_label == "error" && Current_routine) {
    Current_routine->state = COMPLETED;
  }


  if (Trace_stream) Trace_stream->newline();
  return os;
}

#define CLEAR_TRACE  delete Trace_stream, Trace_stream = new trace_stream;

#define DUMP(label)  if (Trace_stream) cerr << Trace_stream->readable_contents(label);

// All scenarios save their traces in the repo, just like code. This gives
// future readers more meat when they try to make sense of a new project.
static string Trace_dir = ".traces/";
string Trace_file;

// Trace_stream is a resource, lease_tracer uses RAII to manage it.
struct lease_tracer {
  lease_tracer() { Trace_stream = new trace_stream; }
  ~lease_tracer() {
    if (!Trace_stream) return;  // in case tests close Trace_stream
    if (!Trace_file.empty()) {
      ofstream fout((Trace_dir+Trace_file).c_str());
      fout << Trace_stream->readable_contents("");
      fout.close();
    }
    delete Trace_stream, Trace_stream = NULL, Trace_file = "";
  }
};

#define START_TRACING_UNTIL_END_OF_SCOPE  lease_tracer leased_tracer;
bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) {
  if (!Trace_stream) return false;
  vector<string> expected_lines = split(expected, "");
  long long int curr_expected_line = 0;
  while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
    ++curr_expected_line;
  if (curr_expected_line == SIZE(expected_lines)) return true;
  string label, contents;
  split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    if (label != p->label)
      continue;

    if (contents != trim(p->contents))
      continue;

    ++curr_expected_line;
    while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
      ++curr_expected_line;
    if (curr_expected_line == SIZE(expected_lines)) return true;
    split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
  }

  ++Num_failures;
  cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n";
  DUMP(label);
  Passed = false;
  return false;
}

void split_label_contents(const string& s, string* label, string* contents) {
  static const string delim(": ");
  size_t pos = s.find(delim);
  if (pos == string::npos) {
    *label = "";
    *contents = trim(s);
  }
  else {
    *label = trim(s.substr(0, pos));
    *contents = trim(s.substr(pos+SIZE(delim)));
  }
}



int trace_count(string label) {
  return trace_count(label, "");
}

int trace_count(string label, string line) {
  long result = 0;
  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    if (label == p->label) {
      if (line == "" || trim(line) == trim(p->contents))
        ++result;
    }
  }
  return result;
}

#define CHECK_TRACE_CONTAINS_ERROR()  CHECK(trace_count("error") > 0)
#define CHECK_TRACE_DOESNT_CONTAIN_ERROR() \
  if (trace_count("error") > 0) { \
    ++Num_failures; \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): unexpected errors\n"; \
    DUMP("error"); \
    Passed = false; \
    return; \
  }

#define CHECK_TRACE_COUNT(label, count) \
  if (trace_count(label) != (count)) { \
    ++Num_failures; \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): trace_count of " << label << " should be " << count << '\n'; \
    cerr << "  got " << trace_count(label) << '\n';  /* multiple eval */ \
    DUMP(label); \
    Passed = false; \
    return;  /* Currently we stop at the very first failure. */ \
  }

bool trace_doesnt_contain(string label, string line) {
  return trace_count(label, line) == 0;
}

bool trace_doesnt_contain(string expected) {
  vector<string> tmp = split_first(expected, ": ");
  return trace_doesnt_contain(tmp.at(0), tmp.at(1));
}

#define CHECK_TRACE_DOESNT_CONTAIN(...)  CHECK(trace_doesnt_contain(__VA_ARGS__))



vector<string> split(string s, string delim) {
  vector<string> result;
  size_t begin=0, end=s.find(delim);
  while (true) {
    if (end == string::npos) {
      result.push_back(string(s, begin, string::npos));
      break;
    }
    result.push_back(string(s, begin, end-begin));
    begin = end+SIZE(delim);
    end = s.find(delim, begin);
  }
  return result;
}

vector<string> split_first(string s, string delim) {
  vector<string> result;
  size_t end=s.find(delim);
  result.push_back(string(s, 0, end));
  if (end != string::npos)
    result.push_back(string(s, end+SIZE(delim), string::npos));
  return result;
}

string trim(const string& s) {
  string::const_iterator first = s.begin();
  while (first != s.end() && isspace(*first))
    ++first;
  if (first == s.end()) return "";

  string::const_iterator last = --s.end();
  while (last != s.begin() && isspace(*last))
    --last;
  ++last;
  return string(first, last);
}

trace_stream* Save_trace_stream = NULL;
string Save_trace_file;
vector<recipe_ordinal> Save_recently_added_recipes;
vector<recipe_ordinal> Save_recently_added_shape_shifting_recipes;
// End Tracing  // hack to ensure most code in this layer comes before anything else

int main() {
  // Begin Transforms
    // Begin Instruction Inserting/Deleting Transforms
    Transform.push_back(insert_fragments);  // NOT idempotent
    Transform.push_back(check_insert_fragments);  // idempotent
    Transform.push_back(rewrite_stashes_to_text);
    // End Instruction Inserting/Deleting Transforms
    // Begin Instruction Modifying Transforms
    Transform.push_back(check_header_ingredients);  // idempotent
    Transform.push_back(fill_in_reply_ingredients);  // idempotent
    Transform.push_back(check_or_set_types_by_name);  // idempotent
    // Begin Type Modifying Transforms
    Transform.push_back(deduce_types_from_header);  // idempotent
    Transform.push_back(check_or_set_invalid_types);  // idempotent
    // End Type Modifying Transforms
    Transform.push_back(collect_surrounding_spaces);  // idempotent
    Transform.push_back(transform_names);  // idempotent
    Transform.push_back(resolve_ambiguous_calls);  // idempotent
    Transform.push_back(update_instruction_operations);  // idempotent
    Transform.push_back(transform_braces);  // idempotent
    Transform.push_back(transform_labels);  // idempotent
    // End Instruction Modifying Transforms
  Transform.push_back(check_immutable_ingredients);  // idempotent
  // End Transforms
  // Begin Checks
  Transform.push_back(check_instruction);  // idempotent
  Transform.push_back(check_indirect_calls_against_header);  // idempotent
  Transform.push_back(check_calls_against_header);  // idempotent
  Transform.push_back(transform_new_to_allocate);  // idempotent
  Transform.push_back(check_merge_calls);
  Transform.push_back(check_types_of_reply_instructions);
  Transform.push_back(check_default_space);  // idempotent
  Transform.push_back(check_reply_instructions_against_header);  // idempotent
  // End Checks

  setup_types();
  setup_recipes();
  assert(MAX_PRIMITIVE_RECIPES < 200);  // level 0 is primitives; until 199
  Next_recipe_ordinal = 200;
  put(Recipe_ordinal, "main", Next_recipe_ordinal++);
  put(Recipe_variants, "main", vector<recipe_ordinal>());  // since we manually added main to Recipe_ordinal
  Literal_type_names.insert("number");
  Literal_type_names.insert("character");

  load_permanently("core.mu");
  for (long long int t = 0; t < SIZE(Transform); ++t) {
    for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
      recipe& r = p->second;
      if (r.steps.empty()) continue;
      if (r.transformed_until != t-1) continue;
      if (any_type_ingredient_in_header(/*recipe_ordinal*/p->first)) continue;
      (*Transform.at(t))(/*recipe_ordinal*/p->first);
      r.transformed_until = t;
    }
  }
  load(
    "recipe new-editor [\n"
    "  local-scope\n"
    "  init:address:shared:list:character <- push 97/a, 0\n"
    "]\n");
  cerr << "AAA " << contains_key(Type_ordinal, "_elem") << '\n';
  for (long long int t = 0; t < SIZE(Transform); ++t) {
    cerr << "BBB " << t << ' ' << contains_key(Type_ordinal, "_elem") << '\n';
    for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
      recipe& r = p->second;
      if (r.steps.empty()) continue;
      if (r.transformed_until != t-1) continue;
      cerr << "CCC " << t << ' ' << p->second.name << ' ' << contains_key(Type_ordinal, "_elem") << '\n';
      if (any_type_ingredient_in_header(/*recipe_ordinal*/p->first)) continue;
      (*Transform.at(t))(/*recipe_ordinal*/p->first);
      r.transformed_until = t;
    }
  }
  parse_int_reagents();  // do this after all other transforms have run
  check_container_field_types();
  test_replace_type_ingredients_entire();
  return 0;
}

bool is_integer(const string& s) {
  return s.find_first_not_of("0123456789-") == string::npos
      && s.find('-', 1) == string::npos
      && s.find_first_of("0123456789") != string::npos;
}

long long int to_integer(string n) {
  char* end = NULL;
  // safe because string.c_str() is guaranteed to be null-terminated
  long long int result = strtoll(n.c_str(), &end, /*any base*/0);
  if (*end != '\0') cerr << "tried to convert " << n << " to number\n";
  assert(*end == '\0');
  return result;
}

void test_is_integer() {
  CHECK(is_integer("1234"));
  CHECK(is_integer("-1"));
  CHECK(!is_integer("234.0"));
  CHECK(is_integer("-567"));
  CHECK(!is_integer("89-0"));
  CHECK(!is_integer("-"));
  CHECK(!is_integer("1e3"));  // not supported
}


void test_trace_check_compares() {
  trace("test layer") << "foo" << end();
  CHECK_TRACE_CONTENTS("test layer: foo");
}

void test_trace_check_ignores_other_layers() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 2") << "bar" << end();
  CHECK_TRACE_CONTENTS("test layer 1: foo");
  CHECK_TRACE_DOESNT_CONTAIN("test layer 2: foo");
}

void test_trace_check_ignores_leading_whitespace() {
  trace("test layer 1") << " foo" << end();
  CHECK(trace_count("test layer 1", /*too little whitespace*/"foo") == 1);
  CHECK(trace_count("test layer 1", /*too much whitespace*/"  foo") == 1);
}

void test_trace_check_ignores_other_lines() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 1") << "bar" << end();
  CHECK_TRACE_CONTENTS("test layer 1: foo");
}

void test_trace_check_ignores_other_lines2() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 1") << "bar" << end();
  CHECK_TRACE_CONTENTS("test layer 1: bar");
}

void test_trace_ignores_trailing_whitespace() {
  trace("test layer 1") << "foo\n" << end();
  CHECK_TRACE_CONTENTS("test layer 1: foo");
}

void test_trace_ignores_trailing_whitespace2() {
  trace("test layer 1") << "foo " << end();
  CHECK_TRACE_CONTENTS("test layer 1: foo");
}

void test_trace_orders_across_layers() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 2") << "bar" << end();
  trace("test layer 1") << "qux" << end();
  CHECK_TRACE_CONTENTS("test layer 1: footest layer 2: bartest layer 1: qux");
}

void test_trace_supports_count() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 1") << "foo" << end();
  CHECK_EQ(trace_count("test layer 1", "foo"), 2);
}

void test_trace_supports_count2() {
  trace("test layer 1") << "foo" << end();
  trace("test layer 1") << "bar" << end();
  CHECK_EQ(trace_count("test layer 1"), 2);
}

void test_trace_count_ignores_trailing_whitespace() {
  trace("test layer 1") << "foo\n" << end();
  CHECK(trace_count("test layer 1", "foo") == 1);
}

// pending: DUMP tests
// pending: readable_contents() adds newline if necessary.
// pending: raise also prints to stderr.
// pending: raise doesn't print to stderr if Hide_errors is set.
// pending: raise doesn't have to be saved if Hide_errors is set, just printed.
// pending: raise prints to stderr if Trace_stream is NULL.
// pending: raise prints to stderr if Trace_stream is NULL even if Hide_errors is set.
// pending: raise << ... die() doesn't die if Hide_errors is set.



// can't check trace because trace methods call 'split'

void test_split_returns_at_least_one_elem() {
  vector<string> result = split("", ",");
  CHECK_EQ(result.size(), 1);
  CHECK_EQ(result.at(0), "");
}

void test_split_returns_entire_input_when_no_delim() {
  vector<string> result = split("abc", ",");
  CHECK_EQ(result.size(), 1);
  CHECK_EQ(result.at(0), "abc");
}

void test_split_works() {
  vector<string> result = split("abc,def", ",");
  CHECK_EQ(result.size(), 2);
  CHECK_EQ(result.at(0), "abc");
  CHECK_EQ(result.at(1), "def");
}

void test_split_works2() {
  vector<string> result = split("abc,def,ghi", ",");
  CHECK_EQ(result.size(), 3);
  CHECK_EQ(result.at(0), "abc");
  CHECK_EQ(result.at(1), "def");
  CHECK_EQ(result.at(2), "ghi");
}

void test_split_handles_multichar_delim() {
  vector<string> result = split("abc,,def,,ghi", ",,");
  CHECK_EQ(result.size(), 3);
  CHECK_EQ(result.at(0), "abc");
  CHECK_EQ(result.at(1), "def");
  CHECK_EQ(result.at(2), "ghi");
}

void test_trim() {
  CHECK_EQ(trim(""), "");
  CHECK_EQ(trim(" "), "");
  CHECK_EQ(trim("  "), "");
  CHECK_EQ(trim("a"), "a");
  CHECK_EQ(trim(" a"), "a");
  CHECK_EQ(trim("  a"), "a");
  CHECK_EQ(trim("  ab"), "ab");
  CHECK_EQ(trim("a "), "a");
  CHECK_EQ(trim("a  "), "a");
  CHECK_EQ(trim("ab  "), "ab");
  CHECK_EQ(trim(" a "), "a");
  CHECK_EQ(trim("  a  "), "a");
  CHECK_EQ(trim("  ab  "), "ab");
}

void setup_types() {
  Type.clear();  Type_ordinal.clear();
  put(Type_ordinal, "literal", 0);
  Next_type_ordinal = 1;
  // Mu Types Initialization
  type_ordinal number = put(Type_ordinal, "number", Next_type_ordinal++);
  put(Type_ordinal, "location", get(Type_ordinal, "number"));  // wildcard type: either a pointer or a scalar
  get_or_insert(Type, number).name = "number";
  type_ordinal address = put(Type_ordinal, "address", Next_type_ordinal++);
  get_or_insert(Type, address).name = "address";
  type_ordinal boolean = put(Type_ordinal, "boolean", Next_type_ordinal++);
  get_or_insert(Type, boolean).name = "boolean";
  type_ordinal character = put(Type_ordinal, "character", Next_type_ordinal++);
  get_or_insert(Type, character).name = "character";
  // Array types are a special modifier to any other type. For example,
  // array:number or array:address:boolean.
  type_ordinal array = put(Type_ordinal, "array", Next_type_ordinal++);
  get_or_insert(Type, array).name = "array";
  put(Type_ordinal, "literal-string", 0);

  put(Type_ordinal, "offset", 0);

  type_ordinal point = put(Type_ordinal, "point", Next_type_ordinal++);
  get_or_insert(Type, point).size = 2;
  get(Type, point).kind = CONTAINER;
  get(Type, point).name = "point";
  get(Type, point).elements.push_back(reagent("x:number"));
  get(Type, point).elements.push_back(reagent("y:number"));


  // A more complex container, containing another container as one of its
  // elements.
  type_ordinal point_number = put(Type_ordinal, "point-number", Next_type_ordinal++);
  get_or_insert(Type, point_number).size = 2;
  get(Type, point_number).kind = CONTAINER;
  get(Type, point_number).name = "point-number";
  get(Type, point_number).elements.push_back(reagent("xy:point"));
  get(Type, point_number).elements.push_back(reagent("z:number"));

  {
  type_ordinal tmp = put(Type_ordinal, "number-or-point", Next_type_ordinal++);
  get_or_insert(Type, tmp).size = 2;
  get(Type, tmp).kind = EXCLUSIVE_CONTAINER;
  get(Type, tmp).name = "number-or-point";
  get(Type, tmp).elements.push_back(reagent("i:number"));
  get(Type, tmp).elements.push_back(reagent("p:point"));
  }

  put(Type_ordinal, "variant", 0);

  type_ordinal shared = put(Type_ordinal, "shared", Next_type_ordinal++);
  get_or_insert(Type, shared).name = "shared";
  put(Type_ordinal, "type", 0);

  put(Type_ordinal, "label", 0);

  put(Type_ordinal, "recipe-literal", 0);
  // 'recipe' variables can store recipe-literal
  type_ordinal recipe = put(Type_ordinal, "recipe", Next_type_ordinal++);
  get_or_insert(Type, recipe).name = "recipe";

  // End Mu Types Initialization
}
void teardown_types() {
  for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) {
    for (long long int i = 0; i < SIZE(p->second.elements); ++i)
      p->second.elements.clear();
  }
  Type_ordinal.clear();
}
void setup_recipes() {
  Recipe.clear();  Recipe_ordinal.clear();
  put(Recipe_ordinal, "idle", IDLE);
  // Primitive Recipe Numbers
  put(Recipe_ordinal, "copy", COPY);
  put(Recipe_ordinal, "add", ADD);
  put(Recipe_ordinal, "subtract", SUBTRACT);
  put(Recipe_ordinal, "multiply", MULTIPLY);
  put(Recipe_ordinal, "divide", DIVIDE);
  put(Recipe_ordinal, "divide-with-remainder", DIVIDE_WITH_REMAINDER);
  put(Recipe_ordinal, "shift-left", SHIFT_LEFT);
  put(Recipe_ordinal, "shift-right", SHIFT_RIGHT);
  put(Recipe_ordinal, "and-bits", AND_BITS);
  put(Recipe_ordinal, "or-bits", OR_BITS);
  put(Recipe_ordinal, "xor-bits", XOR_BITS);
  put(Recipe_ordinal, "flip-bits", FLIP_BITS);
  put(Recipe_ordinal, "and", AND);
  put(Recipe_ordinal, "or", OR);
  put(Recipe_ordinal, "not", NOT);
  put(Recipe_ordinal, "jump", JUMP);
  put(Recipe_ordinal, "jump-if", JUMP_IF);
  put(Recipe_ordinal, "jump-unless", JUMP_UNLESS);
  put(Recipe_ordinal, "equal", EQUAL);
  put(Recipe_ordinal, "greater-than", GREATER_THAN);
  put(Recipe_ordinal, "lesser-than", LESSER_THAN);
  put(Recipe_ordinal, "greater-or-equal", GREATER_OR_EQUAL);
  put(Recipe_ordinal, "lesser-or-equal", LESSER_OR_EQUAL);
  put(Recipe_ordinal, "trace", TRACE);
  put(Recipe_ordinal, "stash", STASH);
  put(Recipe_ordinal, "hide-errors", HIDE_ERRORS);
  put(Recipe_ordinal, "show-errors", SHOW_ERRORS);
  put(Recipe_ordinal, "trace-until", TRACE_UNTIL);
  put(Recipe_ordinal, "$dump-trace", _DUMP_TRACE);
  put(Recipe_ordinal, "$clear-trace", _CLEAR_TRACE);
  put(Recipe_ordinal, "$save-trace", _SAVE_TRACE);
  put(Recipe_ordinal, "assert", ASSERT);
  put(Recipe_ordinal, "$print", _PRINT);
  put(Recipe_ordinal, "$exit", _EXIT);
  put(Recipe_ordinal, "$system", _SYSTEM);
  put(Recipe_ordinal, "$dump-memory", _DUMP_MEMORY);
  put(Recipe_ordinal, "$log", _LOG);
  put(Recipe_ordinal, "get", GET);
  put(Recipe_ordinal, "get-address", GET_ADDRESS);
  put(Recipe_ordinal, "merge", MERGE);
  put(Recipe_ordinal, "$dump", _DUMP);
  put(Recipe_ordinal, "$foo", _FOO);
  put(Recipe_ordinal, "create-array", CREATE_ARRAY);
  put(Recipe_ordinal, "index", INDEX);
  put(Recipe_ordinal, "index-address", INDEX_ADDRESS);
  put(Recipe_ordinal, "length", LENGTH);
  put(Recipe_ordinal, "maybe-convert", MAYBE_CONVERT);
  put(Recipe_ordinal, "next-ingredient", NEXT_INGREDIENT);
  put(Recipe_ordinal, "rewind-ingredients", REWIND_INGREDIENTS);
  put(Recipe_ordinal, "ingredient", INGREDIENT);
  put(Recipe_ordinal, "reply", REPLY);
  put(Recipe_ordinal, "new", NEW);
  put(Recipe_ordinal, "allocate", ALLOCATE);
  put(Recipe_ordinal, "abandon", ABANDON);
  put(Recipe_ordinal, "to-location-array", TO_LOCATION_ARRAY);
  put(Recipe_ordinal, "break", BREAK);
  put(Recipe_ordinal, "break-if", BREAK_IF);
  put(Recipe_ordinal, "break-unless", BREAK_UNLESS);
  put(Recipe_ordinal, "loop", LOOP);
  put(Recipe_ordinal, "loop-if", LOOP_IF);
  put(Recipe_ordinal, "loop-unless", LOOP_UNLESS);
  put(Recipe_ordinal, "run", RUN);
  put(Recipe_ordinal, "memory-should-contain", MEMORY_SHOULD_CONTAIN);
  put(Recipe_ordinal, "trace-should-contain", TRACE_SHOULD_CONTAIN);
  put(Recipe_ordinal, "trace-should-not-contain", TRACE_SHOULD_NOT_CONTAIN);
  put(Recipe_ordinal, "check-trace-count-for-label", CHECK_TRACE_COUNT_FOR_LABEL);
  put(Recipe_ordinal, "next-ingredient-without-typechecking", NEXT_INGREDIENT_WITHOUT_TYPECHECKING);
  put(Recipe_ordinal, "call", CALL);
  put(Recipe_ordinal, "start-running", START_RUNNING);
  put(Recipe_ordinal, "routine-state", ROUTINE_STATE);
  put(Recipe_ordinal, "restart", RESTART);
  put(Recipe_ordinal, "stop", STOP);
  put(Recipe_ordinal, "$dump-routines", _DUMP_ROUTINES);
  put(Recipe_ordinal, "limit-time", LIMIT_TIME);
  put(Recipe_ordinal, "wait-for-location", WAIT_FOR_LOCATION);
  put(Recipe_ordinal, "wait-for-routine", WAIT_FOR_ROUTINE);
  put(Recipe_ordinal, "switch", SWITCH);
  put(Recipe_ordinal, "random", RANDOM);
  put(Recipe_ordinal, "make-random-nondeterministic", MAKE_RANDOM_NONDETERMINISTIC);
  put(Recipe_ordinal, "round", ROUND);
  put(Recipe_ordinal, "hash", HASH);
  put(Recipe_ordinal, "hash_old", HASH_OLD);
  put(Recipe_ordinal, "open-console", OPEN_CONSOLE);
  put(Recipe_ordinal, "close-console", CLOSE_CONSOLE);
  put(Recipe_ordinal, "clear-display", CLEAR_DISPLAY);
  put(Recipe_ordinal, "sync-display", SYNC_DISPLAY);
  put(Recipe_ordinal, "clear-line-on-display", CLEAR_LINE_ON_DISPLAY);
  put(Recipe_ordinal, "print-character-to-display", PRINT_CHARACTER_TO_DISPLAY);
  put(Recipe_ordinal, "cursor-position-on-display", CURSOR_POSITION_ON_DISPLAY);
  put(Recipe_ordinal, "move-cursor-on-display", MOVE_CURSOR_ON_DISPLAY);
  put(Recipe_ordinal, "move-cursor-down-on-display", MOVE_CURSOR_DOWN_ON_DISPLAY);
  put(Recipe_ordinal, "move-cursor-up-on-display", MOVE_CURSOR_UP_ON_DISPLAY);
  put(Recipe_ordinal, "move-cursor-right-on-display", MOVE_CURSOR_RIGHT_ON_DISPLAY);
  put(Recipe_ordinal, "move-cursor-left-on-display", MOVE_CURSOR_LEFT_ON_DISPLAY);
  put(Recipe_ordinal, "display-width", DISPLAY_WIDTH);
  put(Recipe_ordinal, "display-height", DISPLAY_HEIGHT);
  put(Recipe_ordinal, "hide-cursor-on-display", HIDE_CURSOR_ON_DISPLAY);
  put(Recipe_ordinal, "show-cursor-on-display", SHOW_CURSOR_ON_DISPLAY);
  put(Recipe_ordinal, "hide-display", HIDE_DISPLAY);
  put(Recipe_ordinal, "show-display", SHOW_DISPLAY);
  put(Recipe_ordinal, "wait-for-some-interaction", WAIT_FOR_SOME_INTERACTION);
  put(Recipe_ordinal, "check-for-interaction", CHECK_FOR_INTERACTION);
  put(Recipe_ordinal, "interactions-left?", INTERACTIONS_LEFT);
  put(Recipe_ordinal, "clear-display-from", CLEAR_DISPLAY_FROM);
  put(Recipe_ordinal, "screen-should-contain", SCREEN_SHOULD_CONTAIN);
  put(Recipe_ordinal, "screen-should-contain-in-color", SCREEN_SHOULD_CONTAIN_IN_COLOR);
  put(Recipe_ordinal, "$dump-screen", _DUMP_SCREEN);
  put(Recipe_ordinal, "assume-console", ASSUME_CONSOLE);
  put(Recipe_ordinal, "replace-in-console", REPLACE_IN_CONSOLE);
  put(Recipe_ordinal, "$browse-trace", _BROWSE_TRACE);
  put(Recipe_ordinal, "run-interactive", RUN_INTERACTIVE);
  put(Recipe_ordinal, "$start-tracking-products", _START_TRACKING_PRODUCTS);
  put(Recipe_ordinal, "$stop-tracking-products", _STOP_TRACKING_PRODUCTS);
  put(Recipe_ordinal, "$most-recent-products", _MOST_RECENT_PRODUCTS);
  put(Recipe_ordinal, "save-errors-warnings", SAVE_ERRORS_WARNINGS);
  put(Recipe_ordinal, "save-app-trace", SAVE_APP_TRACE);
  put(Recipe_ordinal, "$cleanup-run-interactive", _CLEANUP_RUN_INTERACTIVE);
  put(Recipe_ordinal, "reload", RELOAD);
  put(Recipe_ordinal, "restore", RESTORE);
  put(Recipe_ordinal, "save", SAVE);
  // End Primitive Recipe Numbers
}
recipe::recipe() {
  transformed_until = -1;

  has_header = false;

  // End recipe Constructor
}

instruction::instruction() :is_label(false), operation(IDLE) {
  tangle_done = false;

  // End instruction Constructor
}
void instruction::clear() { is_label=false; label.clear(); name.clear(); old_name.clear(); operation=IDLE; ingredients.clear(); products.clear(); original_string.clear(); }
bool instruction::is_empty() { return !is_label && name.empty(); }

// Reagents have the form <name>:<type>:<type>:.../<property>/<property>/...
reagent::reagent(string s) :original_string(s), type(NULL), value(0), initialized(false) {
  // Parsing reagent(string s)
  if (s.at(0) == '{') {
    assert(properties.empty());
    istringstream in(s);
    in >> std::noskipws;
    in.get();  // skip '{'
    name = slurp_key(in);
    if (name.empty()) {
      raise_error << "invalid reagent " << s << " without a name\n";
      return;
    }
    if (name == "}") {
      raise_error << "invalid empty reagent " << s << '\n';
      return;
    }
    {
      string_tree* value = new string_tree(next_word(in));
      value = parse_string_tree(value);

      // End Parsing Reagent Type Property(value)
      type = new_type_tree(value);
      delete value;
    }
    while (has_data(in)) {
      string key = slurp_key(in);
      if (key.empty()) continue;
      if (key == "}") continue;
      string_tree* value = new string_tree(next_word(in));
      value = parse_string_tree(value);
      // End Parsing Reagent Property(value)
      properties.push_back(pair<string, string_tree*>(key, value));
    }
    return;
  }

  if (is_noninteger(s)) {
    name = s;
    type = new type_tree("literal-fractional-number", 0);
    set_value(to_double(s));
    return;
  }

  if (s.at(0) == '[') {
    assert(*s.rbegin() == ']');
    // delete [] delimiters
    s.erase(0, 1);
    strip_last(s);
    name = s;
    type = new type_tree("literal-string", 0);
    return;
  }


  istringstream in(s);
  in >> std::noskipws;
  // name and type
  istringstream first_row(slurp_until(in, '/'));
  first_row >> std::noskipws;
  name = slurp_until(first_row, ':');
  string_tree* type_names = parse_property_list(first_row);
  type = new_type_tree(type_names);
  delete type_names;
  // special cases
  if (is_integer(name) && type == NULL)
    type = new type_tree("literal", get(Type_ordinal, "literal"));
  if (name == "_" && type == NULL)
    type = new type_tree("literal", get(Type_ordinal, "literal"));
  // other properties
  while (has_data(in)) {
    istringstream row(slurp_until(in, '/'));
    row >> std::noskipws;
    string key = slurp_until(row, ':');
    string_tree* value = parse_property_list(row);
    properties.push_back(pair<string, string_tree*>(key, value));
  }
  {
    while (!name.empty() && name.at(0) == '*') {
      name.erase(0, 1);
      properties.push_back(pair<string, string_tree*>("lookup", NULL));
    }
    if (name.empty())
      raise_error << "illegal name " << original_string << '\n' << end();
  }


  // End Parsing reagent
}

string_tree* parse_property_list(istream& in) {
  skip_whitespace_but_not_newline(in);
  if (!has_data(in)) return NULL;
  string_tree* result = new string_tree(slurp_until(in, ':'));
  result->right = parse_property_list(in);
  return result;
}

// TODO: delete
type_tree* new_type_tree(const string_tree* properties) {
  if (!properties) return NULL;
  type_tree* result = new type_tree("", 0);
  if (!properties->value.empty()) {
    const string& type_name = result->name = properties->value;
    if (contains_key(Type_ordinal, type_name))
      result->value = get(Type_ordinal, type_name);
    else if (is_integer(type_name))  // sometimes types will contain non-type tags, like numbers for the size of an array
      result->value = 0;
    else if (properties->value != "->")  // used in recipe types
      result->value = -1;  // should never happen; will trigger errors later
  }
  result->left = new_type_tree(properties->left);
  result->right = new_type_tree(properties->right);
  return result;
}


reagent::reagent(const reagent& old) {
  original_string = old.original_string;
  name = old.name;
  value = old.value;
  initialized = old.initialized;
  properties.clear();
  for (long long int i = 0; i < SIZE(old.properties); ++i) {
    properties.push_back(pair<string, string_tree*>(old.properties.at(i).first,
                                                    old.properties.at(i).second ? new string_tree(*old.properties.at(i).second) : NULL));
  }
  type = old.type ? new type_tree(*old.type) : NULL;
}

type_tree::type_tree(const type_tree& old) {
  name = old.name;
  value = old.value;
  left = old.left ? new type_tree(*old.left) : NULL;
  right = old.right ? new type_tree(*old.right) : NULL;
}

string_tree::string_tree(const string_tree& old) {  // :value(old.value) {
  value = old.value;
  left = old.left ? new string_tree(*old.left) : NULL;
  right = old.right ? new string_tree(*old.right) : NULL;
}

reagent& reagent::operator=(const reagent& old) {
  original_string = old.original_string;
  properties.clear();
  for (long long int i = 0; i < SIZE(old.properties); ++i)
    properties.push_back(pair<string, string_tree*>(old.properties.at(i).first, old.properties.at(i).second ? new string_tree(*old.properties.at(i).second) : NULL));
  name = old.name;
  value = old.value;
  initialized = old.initialized;
  type = old.type ? new type_tree(*old.type) : NULL;
  return *this;
}

reagent::~reagent() {
  clear();
}

void reagent::clear() {
  for (long long int i = 0; i < SIZE(properties); ++i) {
    if (properties.at(i).second) {
      delete properties.at(i).second;
      properties.at(i).second = NULL;
    }
  }
  delete type;
  type = NULL;
}
type_tree::~type_tree() {
  delete left;
  delete right;
}
string_tree::~string_tree() {
  delete left;
  delete right;
}

string slurp_until(istream& in, char delim) {
  ostringstream out;
  char c;
  while (in >> c) {
    if (c == delim) {
      // drop the delim
      break;
    }
    out << c;
  }
  return out.str();
}

bool has_property(reagent x, string name) {
  for (long long int i = 0; i < SIZE(x.properties); ++i) {
    if (x.properties.at(i).first == name) return true;
  }
  return false;
}

string_tree* property(const reagent& r, const string& name) {
  for (long long int p = 0; p != SIZE(r.properties); ++p) {
    if (r.properties.at(p).first == name)
      return r.properties.at(p).second;
  }
  return NULL;
}

void skip_whitespace_but_not_newline(istream& in) {
  while (true) {
    if (!has_data(in)) break;
    else if (in.peek() == '\n') break;
    else if (isspace(in.peek())) in.get();
    else if (Ignore.find(in.peek()) != string::npos) in.get();
    else break;
  }
}

void dump_memory() {
  for (map<long long int, double>::iterator p = Memory.begin(); p != Memory.end(); ++p) {
    cout << p->first << ": " << no_scientific(p->second) << '\n';
  }
}


string to_string(const recipe& r) {
  ostringstream out;
  out << "recipe " << r.name << " [\n";
  for (long long int i = 0; i < SIZE(r.steps); ++i)
    out << "  " << to_string(r.steps.at(i)) << '\n';
  out << "]\n";
  return out.str();
}

string debug_string(const recipe& x) {
  ostringstream out;
  out << "- recipe " << x.name << '\n';
  // Begin debug_string(recipe x)
  out << "ingredients:\n";
  for (long long int i = 0; i < SIZE(x.ingredients); ++i)
    out << "  " << debug_string(x.ingredients.at(i)) << '\n';
  out << "products:\n";
  for (long long int i = 0; i < SIZE(x.products); ++i)
    out << "  " << debug_string(x.products.at(i)) << '\n';


  for (long long int index = 0; index < SIZE(x.steps); ++index) {
    const instruction& inst = x.steps.at(index);
    out << "inst: " << to_string(inst) << '\n';
    out << "  ingredients\n";
    for (long long int i = 0; i < SIZE(inst.ingredients); ++i)
      out << "    " << debug_string(inst.ingredients.at(i)) << '\n';
    out << "  products\n";
    for (long long int i = 0; i < SIZE(inst.products); ++i)
      out << "    " << debug_string(inst.products.at(i)) << '\n';
  }
  return out.str();
}

string to_string(const instruction& inst) {
  if (inst.is_label) return inst.label;
  ostringstream out;
  for (long long int i = 0; i < SIZE(inst.products); ++i) {
    if (i > 0) out << ", ";
    out << inst.products.at(i).original_string;
  }
  if (!inst.products.empty()) out << " <- ";
  out << inst.name << ' ';
  for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
    if (i > 0) out << ", ";
    out << inst.ingredients.at(i).original_string;
  }
  return out.str();
}

string to_string(const reagent& r) {
  if (is_literal_string(r))
    return emit_literal_string(r.name);

  ostringstream out;
  out << r.name << ": " << names_to_string(r.type);
  if (!r.properties.empty()) {
    out << ", {";
    for (long long int i = 0; i < SIZE(r.properties); ++i) {
      if (i > 0) out << ", ";
      out << "\"" << r.properties.at(i).first << "\": " << to_string(r.properties.at(i).second);
    }
    out << "}";
  }
  return out.str();
}

string debug_string(const reagent& x) {
  ostringstream out;
  out << x.name << ": " << x.value << ' ' << to_string(x.type) << " -- " << to_string(x);
  return out.str();
}

string to_string(const string_tree* property) {
  if (!property) return "()";
  ostringstream out;
  if (!property->left && !property->right)
    // abbreviate a single-node tree to just its contents
    out << '"' << property->value << '"';
  else
    dump(property, out);
  return out.str();
}

void dump(const string_tree* x, ostream& out) {
  if (!x->left && !x->right) {
    out << x->value;
    return;
  }
  out << '(';
  for (const string_tree* curr = x; curr; curr = curr->right) {
    if (curr != x) out << ' ';
    if (curr->left)
      dump(curr->left, out);
    else
      out << '"' << curr->value << '"';
  }
  out << ')';
}

string to_string(const type_tree* type) {
  // abbreviate a single-node tree to just its contents
  if (!type) return "NULLNULLNULL";  // should never happen
  ostringstream out;
  dump(type, out);
  return out.str();
}

void dump(const type_tree* x, ostream& out) {
  if (!x->left && !x->right) {
    out << x->value;
    return;
  }
  out << '(';
  for (const type_tree* curr = x; curr; curr = curr->right) {
    if (curr != x) out << ' ';
    if (curr->left)
      dump(curr->left, out);
    else
      dump(curr->value, out);
  }
  out << ')';
}

void dump(type_ordinal type, ostream& out) {
  if (contains_key(Type, type))
    out << get(Type, type).name;
  else
    out << "?" << type;
}

string names_to_string(const type_tree* type) {
  // abbreviate a single-node tree to just its contents
  if (!type) return "()";  // should never happen
  ostringstream out;
  dump_names(type, out);
  return out.str();
}

void dump_names(const type_tree* type, ostream& out) {
  if (!type->left && !type->right) {
    out << '"' << type->name << '"';
    return;
  }
  out << '(';
  for (const type_tree* curr = type; curr; curr = curr->right) {
    if (curr != type) out << ' ';
    if (curr->left)
      dump_names(curr->left, out);
    else
      out << '"' << curr->name << '"';
  }
  out << ')';
}

string names_to_string_without_quotes(const type_tree* type) {
  // abbreviate a single-node tree to just its contents
  if (!type) return "NULLNULLNULL";  // should never happen
  ostringstream out;
  dump_names_without_quotes(type, out);
  return out.str();
}

void dump_names_without_quotes(const type_tree* type, ostream& out) {
  if (!type->left && !type->right) {
    out << type->name;
    return;
  }
  out << '(';
  for (const type_tree* curr = type; curr; curr = curr->right) {
    if (curr != type) out << ' ';
    if (curr->left)
      dump_names_without_quotes(curr->left, out);
    else
      out << curr->name;
  }
  out << ')';
}


ostream& operator<<(ostream& os, no_scientific x) {
  if (!isfinite(x.x)) {
    // Infinity or NaN
    os << x.x;
    return os;
  }
  ostringstream tmp;
  tmp << std::fixed << x.x;
  os << trim_floating_point(tmp.str());
  return os;
}

string trim_floating_point(const string& in) {
  if (in.empty()) return "";
  long long int len = SIZE(in);
  while (len > 1) {
    if (in.at(len-1) != '0') break;
    --len;
  }
  if (in.at(len-1) == '.') --len;
  return in.substr(0, len);
}

void test_trim_floating_point() {
  CHECK_EQ("", trim_floating_point(""));
  CHECK_EQ("0", trim_floating_point("000000000"));
  CHECK_EQ("1.5", trim_floating_point("1.5000"));
  CHECK_EQ("1.000001", trim_floating_point("1.000001"));
  CHECK_EQ("23", trim_floating_point("23.000000"));
  CHECK_EQ("23", trim_floating_point("23.0"));
  CHECK_EQ("23", trim_floating_point("23."));
  CHECK_EQ("23", trim_floating_point("23"));
  CHECK_EQ("3", trim_floating_point("3.000000"));
  CHECK_EQ("3", trim_floating_point("3.0"));
  CHECK_EQ("3", trim_floating_point("3."));
  CHECK_EQ("3", trim_floating_point("3"));
}


void test_first_recipe() {
  Trace_file = "first_recipe";
  load("recipe main [\n  1:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"");
}
vector<recipe_ordinal> load(string form) {
  istringstream in(form);
  in >> std::noskipws;
  return load(in);
}

vector<recipe_ordinal> load(istream& in) {
  in >> std::noskipws;
  vector<recipe_ordinal> result;
  while (has_data(in)) {
    skip_whitespace_and_comments(in);
    if (!has_data(in)) break;
    string command = next_word(in);
    // Command Handlers
    if (command == "recipe") {
      result.push_back(slurp_recipe(in));
    }
    else if (command == "recipe!") {
      Disable_redefine_warnings = true;
      result.push_back(slurp_recipe(in));
      Disable_redefine_warnings = false;
    }
    else if (command == "container") {
      insert_container(command, CONTAINER, in);
    }

    else if (command == "exclusive-container") {
      insert_container(command, EXCLUSIVE_CONTAINER, in);
    }


    else if (command == "scenario") {
      Scenarios.push_back(parse_scenario(in));
    }

    else if (command == "before") {
      string label = next_word(in);
      recipe tmp;
      slurp_body(in, tmp);
      if (is_waypoint(label))
        Before_fragments[label].steps.insert(Before_fragments[label].steps.end(), tmp.steps.begin(), tmp.steps.end());
      else
        raise_error << "can't tangle before label " << label << '\n' << end();
    }
    else if (command == "after") {
      string label = next_word(in);
      recipe tmp;
      slurp_body(in, tmp);
      if (is_waypoint(label))
        After_fragments[label].steps.insert(After_fragments[label].steps.begin(), tmp.steps.begin(), tmp.steps.end());
      else
        raise_error << "can't tangle after label " << label << '\n' << end();
    }


    // End Command Handlers
    else {
      raise_error << "unknown top-level command: " << command << '\n' << end();
    }
  }
  return result;
}

long long int slurp_recipe(istream& in) {
  recipe result;
  result.name = next_word(in);
  result.original_name = result.name;

  // End Load Recipe Name
  skip_whitespace_but_not_newline(in);
  if (in.peek() != '[') {
    trace(9999, "parse") << "recipe has a header; parsing" << end();
    load_recipe_header(in, result);
  }

  // End Recipe Refinements
  if (result.name.empty())
    raise_error << "empty result.name\n" << end();
  trace(9991, "parse") << "--- defining " << result.name << end();
  if (!contains_key(Recipe_ordinal, result.name))
    put(Recipe_ordinal, result.name, Next_recipe_ordinal++);
  if (Recipe.find(get(Recipe_ordinal, result.name)) != Recipe.end()) {
    trace(9991, "parse") << "already exists" << end();
    if (warn_on_redefine(result.name))
      raise << "redefining recipe " << result.name << "\n" << end();
    Recipe.erase(get(Recipe_ordinal, result.name));
  }
  slurp_body(in, result);
  if (!result.has_header) {
    result.has_header = true;
    for (long long int i = 0; i < SIZE(result.steps); ++i) {
      const instruction& inst = result.steps.at(i);
      if ((inst.name == "reply" && !inst.ingredients.empty())
          || inst.name == "next-ingredient"
          || inst.name == "ingredient"
          || inst.name == "rewind-ingredients") {
        result.has_header = false;
        break;
      }
    }
  }
  if (result.has_header) {
    trace(9999, "parse") << "recipe " << result.name << " has a header" << end();
  }


  // End Recipe Body(result)
  put(Recipe, get(Recipe_ordinal, result.name), result);
  // track added recipes because we may need to undo them in tests; see below
  Recently_added_recipes.push_back(get(Recipe_ordinal, result.name));
  return get(Recipe_ordinal, result.name);
}

void slurp_body(istream& in, recipe& result) {
  in >> std::noskipws;
  skip_whitespace_but_not_newline(in);
  if (in.get() != '[')
    raise_error << "recipe body must begin with '['\n" << end();
  skip_whitespace_and_comments(in);  // permit trailing comment after '['
  instruction curr;
  while (next_instruction(in, &curr)) {
    // rewrite `reply-if a, b, c, ...` to
    //   ```
    //   jump-unless a, 1:offset
    //   reply b, c, ...
    //   ```
    if (curr.name == "reply-if") {
      if (curr.products.empty()) {
        curr.operation = get(Recipe_ordinal, "jump-unless");
        curr.name = "jump-unless";
        vector<reagent> results;
        copy(++curr.ingredients.begin(), curr.ingredients.end(), inserter(results, results.end()));
        curr.ingredients.resize(1);
        curr.ingredients.push_back(reagent("1:offset"));
        result.steps.push_back(curr);
        curr.clear();
        curr.operation = get(Recipe_ordinal, "reply");
        curr.name = "reply";
        curr.ingredients.swap(results);
      }
      else {
        raise_error << "'reply-if' never yields any products\n" << end();
      }
    }
    // rewrite `reply-unless a, b, c, ...` to
    //   ```
    //   jump-if a, 1:offset
    //   reply b, c, ...
    //   ```
    if (curr.name == "reply-unless") {
      if (curr.products.empty()) {
        curr.operation = get(Recipe_ordinal, "jump-if");
        curr.name = "jump-if";
        vector<reagent> results;
        copy(++curr.ingredients.begin(), curr.ingredients.end(), inserter(results, results.end()));
        curr.ingredients.resize(1);
        curr.ingredients.push_back(reagent("1:offset"));
        result.steps.push_back(curr);
        curr.clear();
        curr.operation = get(Recipe_ordinal, "reply");
        curr.name = "reply";
        curr.ingredients.swap(results);
      }
      else {
        raise_error << "'reply-unless' never yields any products\n" << end();
      }
    }

    // rewrite `new-default-space` to
    //   `default-space:address:shared:array:location <- new location:type, number-of-locals:literal`
    // where N is Name[recipe][""]
    if (curr.name == "new-default-space") {
      rewrite_default_space_instruction(curr);
    }
    if (curr.name == "local-scope") {
      rewrite_default_space_instruction(curr);
    }

    if (curr.name == "load-ingredients") {
      curr.clear();
      recipe_ordinal op = get(Recipe_ordinal, "next-ingredient-without-typechecking");
      for (long long int i = 0; i < SIZE(result.ingredients); ++i) {
        curr.operation = op;
        curr.name = "next-ingredient-without-typechecking";
        curr.products.push_back(result.ingredients.at(i));
        result.steps.push_back(curr);
        curr.clear();
      }
    }

    // rewrite `assume-screen width, height` to
    // `screen:address:shared:screen <- new-fake-screen width, height`
    if (curr.name == "assume-screen") {
      curr.name = "new-fake-screen";
      assert(curr.products.empty());
      curr.products.push_back(reagent("screen:address:shared:screen"));
      curr.products.at(0).set_value(SCREEN);
    }

    // End Rewrite Instruction(curr, recipe result)
    trace(9992, "load") << "after rewriting: " << to_string(curr) << end();
    if (!curr.is_empty()) {
      curr.original_string = to_string(curr);
      result.steps.push_back(curr);
    }
  }
}

bool next_instruction(istream& in, instruction* curr) {
  curr->clear();
  skip_whitespace_and_comments(in);
  if (!has_data(in)) {
    raise_error << "0: unbalanced '[' for recipe\n" << end();
    return false;
  }

  vector<string> words;
  while (has_data(in) && in.peek() != '\n') {
    skip_whitespace_but_not_newline(in);
    if (!has_data(in)) {
      raise_error << "1: unbalanced '[' for recipe\n" << end();
      return false;
    }
    string word = next_word(in);
    words.push_back(word);
    skip_whitespace_but_not_newline(in);
  }
  skip_whitespace_and_comments(in);
  if (SIZE(words) == 1 && words.at(0) == "]")
    return false;  // end of recipe

  if (SIZE(words) == 1 && !isalnum(words.at(0).at(0)) && words.at(0).at(0) != '$') {
    curr->is_label = true;
    curr->label = words.at(0);
    trace(9993, "parse") << "label: " << curr->label << end();
    if (!has_data(in)) {
      raise_error << "7: unbalanced '[' for recipe\n" << end();
      return false;
    }
    return true;
  }

  vector<string>::iterator p = words.begin();
  if (find(words.begin(), words.end(), "<-") != words.end()) {
    for (; *p != "<-"; ++p)
      curr->products.push_back(reagent(*p));
    ++p;  // skip <-
  }

  if (p == words.end()) {
    raise_error << "instruction prematurely ended with '<-'\n" << end();
    return false;
  }
  curr->old_name = curr->name = *p;  p++;
  // curr->operation will be set in a later layer

  for (; p != words.end(); ++p)
    curr->ingredients.push_back(reagent(*p));

  trace(9993, "parse") << "instruction: " << curr->name << end();
  trace(9993, "parse") << "  number of ingredients: " << SIZE(curr->ingredients) << end();
  for (vector<reagent>::iterator p = curr->ingredients.begin(); p != curr->ingredients.end(); ++p)
    trace(9993, "parse") << "  ingredient: " << to_string(*p) << end();
  for (vector<reagent>::iterator p = curr->products.begin(); p != curr->products.end(); ++p)
    trace(9993, "parse") << "  product: " << to_string(*p) << end();
  if (!has_data(in)) {
    raise_error << "9: unbalanced '[' for recipe\n" << end();
    return false;
  }
  return true;
}

string next_word(istream& in) {
  skip_whitespace_but_not_newline(in);
  if (in.peek() == '[') {
    string result = slurp_quoted(in);
    skip_whitespace_and_comments_but_not_newline(in);
    return result;
  }

  if (in.peek() == '(')
    return slurp_balanced_bracket(in);
  // treat curlies mostly like parens, but don't mess up labels
  if (start_of_dilated_reagent(in))
    return slurp_balanced_bracket(in);

  // End next_word Special-cases
  ostringstream out;
  slurp_word(in, out);
  skip_whitespace_and_comments_but_not_newline(in);
  return out.str();
}

void slurp_word(istream& in, ostream& out) {
  char c;
  if (has_data(in) && Terminators.find(in.peek()) != string::npos) {
    in >> c;
    out << c;
    return;
  }
  while (in >> c) {
    if (isspace(c) || Terminators.find(c) != string::npos || Ignore.find(c) != string::npos) {
      in.putback(c);
      break;
    }
    out << c;
  }
}

void skip_whitespace_and_comments(istream& in) {
  while (true) {
    if (!has_data(in)) break;
    if (isspace(in.peek())) in.get();
    else if (Ignore.find(in.peek()) != string::npos) in.get();
    else if (in.peek() == '#') skip_comment(in);
    else break;
  }
}

// confusing; move to the next line only to skip a comment, but never otherwise
void skip_whitespace_and_comments_but_not_newline(istream& in) {
  while (true) {
    if (!has_data(in)) break;
    if (in.peek() == '\n') break;
    if (isspace(in.peek())) in.get();
    else if (Ignore.find(in.peek()) != string::npos) in.get();
    else if (in.peek() == '#') skip_comment(in);
    else break;
  }
}

void skip_comment(istream& in) {
  if (has_data(in) && in.peek() == '#') {
    in.get();
    while (has_data(in) && in.peek() != '\n') in.get();
  }
}

bool warn_on_redefine(const string& recipe_name) {
  if (recipe_name.find("scenario-") == 0) return true;



  if (Disable_redefine_warnings) return false;
  return true;
}

// for debugging
void show_rest_of_stream(istream& in) {
  cerr << '^';
  char c;
  while (in >> c)
    cerr << c;
  cerr << "$\n";
  exit(0);
}

void clear_recently_added_recipes() {
  for (long long int i = 0; i < SIZE(Recently_added_recipes); ++i) {
    if (Recently_added_recipes.at(i) >= Reserved_for_tests  // don't renumber existing recipes, like 'interactive'
        && contains_key(Recipe, Recently_added_recipes.at(i)))  // in case previous test had duplicate definitions
      Recipe_ordinal.erase(get(Recipe, Recently_added_recipes.at(i)).name);
    Recipe.erase(Recently_added_recipes.at(i));
  }
  for (map<string, vector<recipe_ordinal> >::iterator p = Recipe_variants.begin(); p != Recipe_variants.end(); ++p) {
    for (long long int i = 0; i < SIZE(p->second); ++i) {
      if (find(Recently_added_recipes.begin(), Recently_added_recipes.end(), p->second.at(i)) != Recently_added_recipes.end())
        p->second.at(i) = -1;  // just leave a ghost
    }
  }

  // Clear Other State For Recently_added_recipes
  for (long long int i = 0; i < SIZE(Recently_added_recipes); ++i) {
    Name.erase(Recently_added_recipes.at(i));
  }

  Recently_added_recipes.clear();
}

void test_parse_comment_outside_recipe() {
  Trace_file = "parse_comment_outside_recipe";
  load("# this comment will be dropped by the tangler, so we need a dummy recipe to stop that\nrecipe f1 [ ]\n# this comment will go through to 'load'\nrecipe main [\n  1:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"");
}
void test_parse_comment_amongst_instruction() {
  Trace_file = "parse_comment_amongst_instruction";
  load("recipe main [\n  # comment\n  1:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"");
}
void test_parse_comment_amongst_instruction_2() {
  Trace_file = "parse_comment_amongst_instruction_2";
  load("recipe main [\n  # comment\n  1:number <- copy 23\n  # comment\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"");
}
void test_parse_comment_amongst_instruction_3() {
  Trace_file = "parse_comment_amongst_instruction_3";
  load("recipe main [\n  1:number <- copy 23\n  # comment\n  2:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 2: \"number\"");
}
void test_parse_comment_after_instruction() {
  Trace_file = "parse_comment_after_instruction";
  load("recipe main [\n  1:number <- copy 23  # comment\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"");
}
void test_parse_label() {
  Trace_file = "parse_label";
  load("recipe main [\n  +foo\n]\n");
  CHECK_TRACE_CONTENTS("parse: label: +foo");
}
void test_parse_dollar_as_recipe_name() {
  Trace_file = "parse_dollar_as_recipe_name";
  load("recipe main [\n  $foo\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: $foo");
}
void test_parse_multiple_properties() {
  Trace_file = "parse_multiple_properties";
  load("recipe main [\n  1:number <- copy 23/foo:bar:baz\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\", {\"foo\": (\"bar\" \"baz\")}parse:   product: 1: \"number\"");
}
void test_parse_multiple_products() {
  Trace_file = "parse_multiple_products";
  load("recipe main [\n  1:number, 2:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   product: 1: \"number\"parse:   product: 2: \"number\"");
}
void test_parse_multiple_ingredients() {
  Trace_file = "parse_multiple_ingredients";
  load("recipe main [\n  1:number, 2:number <- copy 23, 4:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   ingredient: 4: \"number\"parse:   product: 1: \"number\"parse:   product: 2: \"number\"");
}
void test_parse_multiple_types() {
  Trace_file = "parse_multiple_types";
  load("recipe main [\n  1:number, 2:address:number <- copy 23, 4:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: instruction: copyparse:   ingredient: 23: \"literal\"parse:   ingredient: 4: \"number\"parse:   product: 1: \"number\"parse:   product: 2: (\"address\" \"number\")");
}
void test_parse_properties() {
  Trace_file = "parse_properties";
  load("recipe main [\n  1:address:number/lookup <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("parse:   product: 1: (\"address\" \"number\"), {\"lookup\": ()}");
}
void test_parse_comment_terminated_by_eof() {
  Trace_file = "parse_comment_terminated_by_eof";
  load("recipe main [\n"
       "  a:number <- copy 34\n"
       "]\n"
       "# abc");  // no newline after comment
  cerr << ".";  // termination = success
}

void test_warn_on_redefine() {
  Trace_file = "warn_on_redefine";
  Hide_warnings = true;
  load("recipe main [\n  1:number <- copy 23\n]\nrecipe main [\n  1:number <- copy 24\n]\n");
  CHECK_TRACE_CONTENTS("warn: redefining recipe main");
}
void test_redefine_without_warning() {
  Trace_file = "redefine_without_warning";
  Hide_warnings = true;
  load("recipe main [\n  1:number <- copy 23\n]\nrecipe! main [\n  1:number <- copy 24\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("warn: redefining recipe main");
  CHECK_TRACE_COUNT("warn", 0);
}

void transform_all() {
  trace(9990, "transform") << "=== transform_all()" << end();
  for (long long int t = 0; t < SIZE(Transform); ++t) {
//?     cerr << "transform " << t << '\n';
    for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
      recipe& r = p->second;
      if (r.steps.empty()) continue;
      if (r.transformed_until != t-1) continue;
      if (any_type_ingredient_in_header(/*recipe_ordinal*/p->first)) continue;

      // End Transform Checks
      (*Transform.at(t))(/*recipe_ordinal*/p->first);
      r.transformed_until = t;
    }
  }
//?   cerr << "wrapping up transform\n";
  parse_int_reagents();  // do this after all other transforms have run
  check_container_field_types();

  // End Transform All
}

void parse_int_reagents() {
  trace(9991, "transform") << "--- parsing any uninitialized reagents as integers" << end();
//?   cerr << "--- parsing any uninitialized reagents as integers" << '\n';
  for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
    recipe& r = p->second;
    if (r.steps.empty()) continue;
    for (long long int index = 0; index < SIZE(r.steps); ++index) {
      instruction& inst = r.steps.at(index);
      for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
        populate_value(inst.ingredients.at(i));
      }
      for (long long int i = 0; i < SIZE(inst.products); ++i) {
        populate_value(inst.products.at(i));
      }
    }
  }
}

void populate_value(reagent& r) {
  if (r.initialized) return;
  // End Reagent-parsing Exceptions
  if (!is_integer(r.name)) return;
  r.set_value(to_integer(r.name));
}


void update_instruction_operations(recipe_ordinal r) {
  trace(9991, "transform") << "--- compute instruction operations for recipe " << get(Recipe, r).name << end();
  recipe& caller = get(Recipe, r);
//?   cerr << "--- compute instruction operations for recipe " << caller.name << '\n';
  for (long long int index = 0; index < SIZE(caller.steps); ++index) {
    instruction& inst = caller.steps.at(index);
    if (inst.is_label) continue;
    if (!contains_key(Recipe_ordinal, inst.name)) {
      raise_error << maybe(caller.name) << "instruction " << inst.name << " has no recipe\n" << end();
      return;
    }
    inst.operation = get(Recipe_ordinal, inst.name);
    if (contains_key(Recipe, inst.operation) && inst.operation >= MAX_PRIMITIVE_RECIPES
        && any_type_ingredient_in_header(inst.operation)) {
      raise_error << maybe(caller.name) << "instruction " << inst.name << " has no valid specialization\n" << end();
      return;
    }

    // End Instruction Operation Checks
  }
}

// hook to suppress inserting recipe name into errors and warnings (for later layers)
string maybe(string s) {
  if (s == "interactive") return "";

  return s + ": ";
}

// temporarily suppress run
void transform(string form) {
  load(form);
  transform_all();
}


void test_string_literal() {
  Trace_file = "string_literal";
  load("recipe main [\n  1:address:array:character <- copy [abc def]  # copy can't really take a string\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"abc def\": \"literal-string\"");
}
void test_string_literal_with_colons() {
  Trace_file = "string_literal_with_colons";
  load("recipe main [\n  1:address:array:character <- copy [abc:def/ghi]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"abc:def/ghi\": \"literal-string\"");
}
string slurp_quoted(istream& in) {
  ostringstream out;
  assert(has_data(in));  assert(in.peek() == '[');  out << static_cast<char>(in.get());  // slurp the '['
  if (is_code_string(in, out))
    slurp_quoted_comment_aware(in, out);
  else
    slurp_quoted_comment_oblivious(in, out);
  return out.str();
}

// A string is a code string if it contains a newline before any non-whitespace
// todo: support comments before the newline. But that gets messy.
bool is_code_string(istream& in, ostream& out) {
  while (has_data(in)) {
    char c = in.get();
    if (!isspace(c)) {
      in.putback(c);
      return false;
    }
    out << c;
    if (c == '\n') {
      return true;
    }
  }
  return false;
}

// Read a regular string. Regular strings can only contain other regular
// strings.
void slurp_quoted_comment_oblivious(istream& in, ostream& out) {
  int brace_depth = 1;
  while (has_data(in)) {
    char c = in.get();
    if (c == '\\') {
      out << static_cast<char>(in.get());
      continue;
    }
    out << c;
    if (c == '[') ++brace_depth;
    if (c == ']') --brace_depth;
    if (brace_depth == 0) break;
  }
  if (!has_data(in) && brace_depth > 0) {
    raise_error << "unbalanced '['\n" << end();
    out.clear();
  }
}

// Read a code string. Code strings can contain either code or regular strings.
void slurp_quoted_comment_aware(istream& in, ostream& out) {
  char c;
  while (in >> c) {
    if (c == '\\') {
      out << static_cast<char>(in.get());
      continue;
    }
    if (c == '#') {
      out << c;
      while (has_data(in) && in.peek() != '\n') out << static_cast<char>(in.get());
      continue;
    }
    if (c == '[') {
      in.putback(c);
      // recurse
      out << slurp_quoted(in);
      continue;
    }
    out << c;
    if (c == ']') return;
  }
  raise_error << "unbalanced '['\n" << end();
  out.clear();
}

bool is_literal_string(const reagent& x) {
  return x.type && x.type->name == "literal-string";
}

string emit_literal_string(string name) {
  size_t pos = 0;
  while (pos != string::npos)
    pos = replace(name, "\n", "\\n", pos);
  return '"'+name+"\": \"literal-string\"";
}

size_t replace(string& str, const string& from, const string& to, size_t n) {
  size_t result = str.find(from, n);
  if (result != string::npos)
    str.replace(result, from.length(), to);
  return result;
}

void strip_last(string& s) {
  if (!s.empty()) s.erase(SIZE(s)-1);
}

void test_string_literal_nested() {
  Trace_file = "string_literal_nested";
  load("recipe main [\n  1:address:array:character <- copy [abc [def]]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"abc [def]\": \"literal-string\"");
}
void test_string_literal_escaped() {
  Trace_file = "string_literal_escaped";
  load("recipe main [\n  1:address:array:character <- copy [abc \\[def]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"abc [def\": \"literal-string\"");
}
void test_string_literal_escaped_comment_aware() {
  Trace_file = "string_literal_escaped_comment_aware";
  load("recipe main [\n  1:address:array:character <- copy [\nabc \\\\\\[def]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"\\nabc \\[def\": \"literal-string\"");
}
void test_string_literal_and_comment() {
  Trace_file = "string_literal_and_comment";
  load("recipe main [\n  1:address:array:character <- copy [abc]  # comment\n]\n");
  CHECK_TRACE_CONTENTS("parse: --- defining mainparse: instruction: copyparse:   number of ingredients: 1parse:   ingredient: \"abc\": \"literal-string\"parse:   product: 1: (\"address\" \"array\" \"character\")");
}
void test_string_literal_escapes_newlines_in_trace() {
  Trace_file = "string_literal_escapes_newlines_in_trace";
  load("recipe main [\n  copy [abc\ndef]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"abc\\ndef\": \"literal-string\"");
}
void test_string_literal_can_skip_past_comments() {
  Trace_file = "string_literal_can_skip_past_comments";
  load("recipe main [\n  copy [\n    # ']' inside comment\n    bar\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"\\n    # ']' inside comment\\n    bar\\n  \": \"literal-string\"");
}
void test_string_literal_empty() {
  Trace_file = "string_literal_empty";
  load("recipe main [\n  copy []\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: \"\": \"literal-string\"");
}

void test_noninteger_literal() {
  Trace_file = "noninteger_literal";
  load("recipe main [\n  1:number <- copy 3.14159\n]\n");
  CHECK_TRACE_CONTENTS("parse:   ingredient: 3.14159: \"literal-fractional-number\"");
}
bool is_noninteger(const string& s) {
  return s.find_first_not_of("0123456789-.") == string::npos
      && s.find_first_of    ("0123456789-") != string::npos
      && std::count(s.begin(), s.end(), '.') == 1;
}

double to_double(string n) {
  char* end = NULL;
  // safe because string.c_str() is guaranteed to be null-terminated
  double result = strtod(n.c_str(), &end);
  assert(*end == '\0');
  return result;
}

void test_is_noninteger() {
  CHECK(!is_noninteger("1234"));
  CHECK(!is_noninteger("1a2"));
  CHECK(is_noninteger("234.0"));
  CHECK(!is_noninteger("..."));
  CHECK(!is_noninteger("."));
  CHECK(is_noninteger("2."));
  CHECK(is_noninteger(".2"));
}


void test_copy_literal() {
  Trace_file = "copy_literal";
  run("recipe main [\n  1:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:number <- copy 23mem: storing 23 in location 1");
}
void test_copy() {
  Trace_file = "copy";
  run("recipe main [\n  1:number <- copy 23\n  2:number <- copy 1:number\n]\n");
  CHECK_TRACE_CONTENTS("run: 2:number <- copy 1:numbermem: location 1 is 23mem: storing 23 in location 2");
}
void test_copy_multiple() {
  Trace_file = "copy_multiple";
  run("recipe main [\n  1:number, 2:number <- copy 23, 24\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 23 in location 1mem: storing 24 in location 2");
}
void run(recipe_ordinal r) {
  run(new routine(r));
}


void run_current_routine(long long int time_slice)
{  // curly on a separate line, because later layers will modify header
  long long int ninstrs = 0;
  while (Current_routine->state == RUNNING && ninstrs < time_slice)
  {
    // when we reach the end of one call, we may reach the end of the one below
    // it, and the one below that, and so on
    while (current_step_index() >= SIZE(Current_routine->steps())) {
      // Falling Through End Of Recipe
      try_reclaim_locals();
      if (Trace_stream) {
        trace(9999, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end();
        --Trace_stream->callstack_depth;
        assert(Trace_stream->callstack_depth >= 0);
      }
      Current_routine->calls.pop_front();
      if (Current_routine->calls.empty()) return;
      // Complete Call Fallthrough
      // todo: fail if no products returned
      ++current_step_index();
    }

    // Running One Instruction
    ninstrs++;


    if (Current_routine->calls.front().running_step_index == 0
        && any_type_ingredient_in_header(Current_routine->calls.front().running_recipe)) {
    //?   DUMP("");
      raise_error << "ran into unspecialized shape-shifting recipe " << current_recipe_name() << '\n' << end();
    }

    if (current_instruction().is_label) { ++current_step_index(); continue; }
    trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << to_string(current_instruction()) << end();
    if (get_or_insert(Memory, 0) != 0) {
      raise_error << "something wrote to location 0; this should never happen\n" << end();
      put(Memory, 0, 0);
    }
    // read all ingredients from memory, each potentially spanning multiple locations
    vector<vector<double> > ingredients;
    if (should_copy_ingredients()) {
      for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i)
        ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
    }
    // instructions below will write to 'products'
    vector<vector<double> > products;
    switch (current_instruction().operation) {
      // Primitive Recipe Implementations
      case COPY: {
        copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
        break;
      }
      case ADD: {
        double result = 0;
        for (long long int i = 0; i < SIZE(ingredients); ++i) {
          result += ingredients.at(i).at(0);
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case SUBTRACT: {
        double result = ingredients.at(0).at(0);
        for (long long int i = 1; i < SIZE(ingredients); ++i)
          result -= ingredients.at(i).at(0);
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }
      case MULTIPLY: {
        double result = 1;
        for (long long int i = 0; i < SIZE(ingredients); ++i) {
          result *= ingredients.at(i).at(0);
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case DIVIDE: {
        double result = ingredients.at(0).at(0);
        for (long long int i = 1; i < SIZE(ingredients); ++i)
          result /= ingredients.at(i).at(0);
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case DIVIDE_WITH_REMAINDER: {
        products.resize(2);
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        if (b == 0) {
          raise_error << maybe(current_recipe_name()) << "divide by zero in '" << to_string(current_instruction()) << "'\n" << end();
          products.resize(2);
          products.at(0).push_back(0);
          products.at(1).push_back(0);
          break;
        }
        long long int quotient = a / b;
        long long int remainder = a % b;
        // very large integers will lose precision
        products.at(0).push_back(quotient);
        products.at(1).push_back(remainder);
        break;
      }

      case SHIFT_LEFT: {
        // ingredients must be integers
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        products.resize(1);
        if (b < 0) {
          raise_error << maybe(current_recipe_name()) << "second ingredient can't be negative in '" << to_string(current_instruction()) << "'\n" << end();
          products.at(0).push_back(0);
          break;
        }
        products.at(0).push_back(a<<b);
        break;
      }

      case SHIFT_RIGHT: {
        // ingredients must be integers
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        products.resize(1);
        if (b < 0) {
          raise_error << maybe(current_recipe_name()) << "second ingredient can't be negative in '" << to_string(current_instruction()) << "'\n" << end();
          products.at(0).push_back(0);
          break;
        }
        products.at(0).push_back(a>>b);
        break;
      }

      case AND_BITS: {
        // ingredients must be integers
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        products.resize(1);
        products.at(0).push_back(a&b);
        break;
      }

      case OR_BITS: {
        // ingredients must be integers
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        products.resize(1);
        products.at(0).push_back(a|b);
        break;
      }

      case XOR_BITS: {
        // ingredients must be integers
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        long long int b = static_cast<long long int>(ingredients.at(1).at(0));
        products.resize(1);
        products.at(0).push_back(a^b);
        break;
      }

      case FLIP_BITS: {
        // ingredient must be integer
        long long int a = static_cast<long long int>(ingredients.at(0).at(0));
        products.resize(1);
        products.at(0).push_back(~a);
        break;
      }

      case AND: {
        bool result = true;
        for (long long int i = 0; i < SIZE(ingredients); ++i)
          result = result && ingredients.at(i).at(0);
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case OR: {
        bool result = false;
        for (long long int i = 0; i < SIZE(ingredients); ++i)
          result = result || ingredients.at(i).at(0);
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case NOT: {
        products.resize(SIZE(ingredients));
        for (long long int i = 0; i < SIZE(ingredients); ++i) {
          products.at(i).push_back(!ingredients.at(i).at(0));
        }
        break;
      }

      case JUMP: {
        assert(current_instruction().ingredients.at(0).initialized);
        current_step_index() += ingredients.at(0).at(0)+1;
        trace(9998, "run") << "jumping to instruction " << current_step_index() << end();
        continue;  // skip rest of this instruction
      }

      case JUMP_IF: {
        assert(current_instruction().ingredients.at(1).initialized);
        if (!ingredients.at(0).at(0)) {
          trace(9998, "run") << "jump-if fell through" << end();
          break;
        }
        current_step_index() += ingredients.at(1).at(0)+1;
        trace(9998, "run") << "jumping to instruction " << current_step_index() << end();
        continue;  // skip rest of this instruction
      }

      case JUMP_UNLESS: {
        assert(current_instruction().ingredients.at(1).initialized);
        if (ingredients.at(0).at(0)) {
          trace(9998, "run") << "jump-unless fell through" << end();
          break;
        }
        current_step_index() += ingredients.at(1).at(0)+1;
        trace(9998, "run") << "jumping to instruction " << current_step_index() << end();
        continue;  // skip rest of this instruction
      }

      case EQUAL: {
        vector<double>& exemplar = ingredients.at(0);
        bool result = true;
        for (long long int i = 1; i < SIZE(ingredients); ++i) {
          if (!equal(ingredients.at(i).begin(), ingredients.at(i).end(), exemplar.begin())) {
            result = false;
            break;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case GREATER_THAN: {
        bool result = true;
        for (long long int i = /**/1; i < SIZE(ingredients); ++i) {
          if (ingredients.at(i-1).at(0) <= ingredients.at(i).at(0)) {
            result = false;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case LESSER_THAN: {
        bool result = true;
        for (long long int i = /**/1; i < SIZE(ingredients); ++i) {
          if (ingredients.at(i-1).at(0) >= ingredients.at(i).at(0)) {
            result = false;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case GREATER_OR_EQUAL: {
        bool result = true;
        for (long long int i = /**/1; i < SIZE(ingredients); ++i) {
          if (ingredients.at(i-1).at(0) < ingredients.at(i).at(0)) {
            result = false;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case LESSER_OR_EQUAL: {
        bool result = true;
        for (long long int i = /**/1; i < SIZE(ingredients); ++i) {
          if (ingredients.at(i-1).at(0) > ingredients.at(i).at(0)) {
            result = false;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case TRACE: {
        long long int depth = ingredients.at(0).at(0);
        string label = current_instruction().ingredients.at(1).name;
        ostringstream out;
        for (long long int i = 2; i < SIZE(current_instruction().ingredients); ++i) {
          out << print_mu(current_instruction().ingredients.at(i), ingredients.at(i));
        }
        trace(depth, label) << out.str() << end();
        break;
      }


      case STASH: {
        ostringstream out;
        for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) {
          out << print_mu(current_instruction().ingredients.at(i), ingredients.at(i));
        }
        trace(2, "app") << out.str() << end();
        break;
      }

      case HIDE_ERRORS: {
        Hide_errors = true;
        Hide_warnings = true;
        break;
      }

      case SHOW_ERRORS: {
        Hide_errors = false;
        Hide_warnings = false;
        break;
      }

      case TRACE_UNTIL: {
        if (Trace_stream) {
          Trace_stream->collect_depth = ingredients.at(0).at(0);
        }
        break;
      }

      case _DUMP_TRACE: {
        if (ingredients.empty()) {
          DUMP("");
        }
        else {
          DUMP(current_instruction().ingredients.at(0).name);
        }
        break;
      }

      case _CLEAR_TRACE: {
        if (Trace_stream) Trace_stream->past_lines.clear();
        break;
      }

      case _SAVE_TRACE: {
        if (!Trace_file.empty()) {
          ofstream fout((Trace_dir+Trace_file).c_str());
          fout << Trace_stream->readable_contents("");
          fout.close();
        }
        break;
      }


      case ASSERT: {
        if (!ingredients.at(0).at(0)) {
          raise_error << current_instruction().ingredients.at(1).name << '\n' << end();
        }
        break;
      }


      case _PRINT: {
        for (long long int i = 0; i < SIZE(ingredients); ++i) {
          if (is_literal(current_instruction().ingredients.at(i))) {
            trace(9998, "run") << "$print: " << current_instruction().ingredients.at(i).name << end();
            if (has_property(current_instruction().ingredients.at(i), "newline"))
              cout << '\n';
            else
              cout << current_instruction().ingredients.at(i).name;
          }
          else {
            for (long long int j = 0; j < SIZE(ingredients.at(i)); ++j) {
              trace(9998, "run") << "$print: " << ingredients.at(i).at(j) << end();
              if (j > 0) cout << " ";
              cout << no_scientific(ingredients.at(i).at(j));
            }
          }
        }
        cout.flush();
        break;
      }

      case _EXIT: {
        exit(0);
        break;
      }

      case _SYSTEM: {
        if (Current_scenario) break;


        int status = system(current_instruction().ingredients.at(0).name.c_str());
        products.resize(1);
        products.at(0).push_back(status);
        break;
      }

      case _DUMP_MEMORY: {
        dump_memory();
        break;
      }


      case _LOG: {
        ostringstream out;
        for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) {
          out << print_mu(current_instruction().ingredients.at(i), ingredients.at(i));
        }
        LOG << out.str() << '\n';
        break;
      }

      case GET: {
        reagent base = current_instruction().ingredients.at(0);
        // Update GET base in Run
        canonize(base);

        long long int base_address = base.value;
        if (base_address == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        type_ordinal base_type = base.type->value;
        long long int offset = ingredients.at(1).at(0);
        if (offset < 0 || offset >= SIZE(get(Type, base_type).elements)) break;  // copied from Check above
        long long int src = base_address;
        for (long long int i = 0; i < offset; ++i) {
          const type_tree* type = get(Type, base_type).elements.at(i).type;
          if (type->value >= START_TYPE_INGREDIENTS) {
            long long int size = size_of_type_ingredient(type, base.type->right);
            if (!size)
              raise_error << "illegal field type '" << to_string(type) << "' seems to be missing a type ingredient or three\n" << end();
            src += size;
            continue;
          }

          // End GET field Cases
          src += size_of(element_type(base, i));
        }
        trace(9998, "run") << "address to copy is " << src << end();
        reagent tmp = element_type(base, offset);
        tmp.properties.push_back(pair<string, string_tree*>("raw", NULL));


        tmp.set_value(src);
        trace(9998, "run") << "its type is " << to_string(tmp.type) << end();
        products.push_back(read_memory(tmp));
        break;
      }

      case GET_ADDRESS: {
        reagent base = current_instruction().ingredients.at(0);
        // Update GET_ADDRESS base in Run
        canonize(base);


        long long int base_address = base.value;
        if (base_address == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        type_ordinal base_type = base.type->value;
        long long int offset = ingredients.at(1).at(0);
        if (offset < 0 || offset >= SIZE(get(Type, base_type).elements)) break;  // copied from Check above
        long long int result = base_address;
        for (long long int i = 0; i < offset; ++i) {
          const type_tree* type = get(Type, base_type).elements.at(i).type;
          if (type->value >= START_TYPE_INGREDIENTS) {
            long long int size = size_of_type_ingredient(type, base.type->right);
            if (!size)
              raise_error << "illegal type '" << to_string(type) << "' seems to be missing a type ingredient or three\n" << end();
            result += size;
            continue;
          }


          // End GET_ADDRESS field Cases
          result += size_of(element_type(base, i));
        }
        trace(9998, "run") << "address to copy is " << result << end();
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case MERGE: {
        products.resize(1);
        for (long long int i = 0; i < SIZE(ingredients); ++i)
          for (long long int j = 0; j < SIZE(ingredients.at(i)); ++j)
            products.at(0).push_back(ingredients.at(i).at(j));
        break;
      }


      case _DUMP: {
        reagent after_canonize = current_instruction().ingredients.at(0);
        canonize(after_canonize);
        cerr << maybe(current_recipe_name()) << current_instruction().ingredients.at(0).name << ' ' << no_scientific(current_instruction().ingredients.at(0).value) << " => " << no_scientific(after_canonize.value) << " => " << no_scientific(get_or_insert(Memory, after_canonize.value)) << '\n';
        break;
      }

      case _FOO: {
        if (current_instruction().ingredients.empty()) {
          if (foo != -1) cerr << foo << ": " << no_scientific(get_or_insert(Memory, foo)) << '\n';
          else cerr << '\n';
        }
        else {
          reagent tmp = current_instruction().ingredients.at(0);
          canonize(tmp);
          foo = tmp.value;
        }
        break;
      }

      case CREATE_ARRAY: {
        reagent product = current_instruction().products.at(0);
        canonize(product);
        long long int base_address = product.value;
        long long int array_size = to_integer(product.type->right->right->name);
        // initialize array size, so that size_of will work
        put(Memory, base_address, array_size);  // in array elements
        long long int size = size_of(product);  // in locations
        trace(9998, "run") << "creating array of size " << size << '\n' << end();
        // initialize array
        for (long long int i = 1; i <= size_of(product); ++i) {
          put(Memory, base_address+i, 0);
        }
        // dummy product; doesn't actually do anything
        products.resize(1);
        products.at(0).push_back(array_size);
        break;
      }

      case INDEX: {
        reagent base = current_instruction().ingredients.at(0);
        canonize(base);
        long long int base_address = base.value;
        trace(9998, "run") << "base address is " << base_address << end();
        if (base_address == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        reagent offset = current_instruction().ingredients.at(1);
        canonize(offset);
        vector<double> offset_val(read_memory(offset));
        type_tree* element_type = array_element(base.type);
        if (offset_val.at(0) < 0 || offset_val.at(0) >= get_or_insert(Memory, base_address)) {
          raise_error << maybe(current_recipe_name()) << "invalid index " << no_scientific(offset_val.at(0)) << '\n' << end();
          break;
        }
        long long int src = base_address + 1 + offset_val.at(0)*size_of(element_type);
        trace(9998, "run") << "address to copy is " << src << end();
        trace(9998, "run") << "its type is " << get(Type, element_type->value).name << end();
        reagent tmp;
        tmp.properties.push_back(pair<string, string_tree*>("raw", NULL));


        tmp.set_value(src);
        tmp.type = new type_tree(*element_type);
        products.push_back(read_memory(tmp));
        break;
      }

      case INDEX_ADDRESS: {
        reagent base = current_instruction().ingredients.at(0);
        canonize(base);
        long long int base_address = base.value;
        if (base_address == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        reagent offset = current_instruction().ingredients.at(1);
        canonize(offset);
        vector<double> offset_val(read_memory(offset));
        type_tree* element_type = array_element(base.type);
        if (offset_val.at(0) < 0 || offset_val.at(0) >= get_or_insert(Memory, base_address)) {
          raise_error << maybe(current_recipe_name()) << "invalid index " << no_scientific(offset_val.at(0)) << '\n' << end();
          break;
        }
        long long int result = base_address + 1 + offset_val.at(0)*size_of(element_type);
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case LENGTH: {
        reagent x = current_instruction().ingredients.at(0);
        canonize(x);
        if (x.value == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        products.resize(1);
        products.at(0).push_back(get_or_insert(Memory, x.value));
        break;
      }

      case MAYBE_CONVERT: {
        reagent base = current_instruction().ingredients.at(0);
        canonize(base);
        long long int base_address = base.value;
        if (base_address == 0) {
          raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << to_string(current_instruction()) << "'\n" << end();
          break;
        }
        long long int tag = current_instruction().ingredients.at(1).value;
        long long int result;
        if (tag == static_cast<long long int>(get_or_insert(Memory, base_address))) {
          result = base_address+1;
        }
        else {
          result = 0;
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }

      case NEXT_INGREDIENT: {
        assert(!Current_routine->calls.empty());
        if (current_call().next_ingredient_to_process < SIZE(current_call().ingredient_atoms)) {
          reagent product = current_instruction().products.at(0);
          canonize_type(product);
          if (current_recipe_name() == "main") {
            // no ingredient types since the call might be implicit; assume ingredients are always strings
            // todo: how to test this?
            if (!is_mu_string(product))
              raise_error << "main: wrong type for ingredient " << product.original_string << '\n' << end();
          }
          else if (!types_coercible(product,
                                    current_call().ingredients.at(current_call().next_ingredient_to_process))) {
            raise_error << maybe(current_recipe_name()) << "wrong type for ingredient " << product.original_string << '\n' << end();
            // End next-ingredient Type Mismatch Error
          }
          products.push_back(
              current_call().ingredient_atoms.at(current_call().next_ingredient_to_process));
          assert(SIZE(products) == 1);  products.resize(2);  // push a new vector
          products.at(1).push_back(1);
          ++current_call().next_ingredient_to_process;
        }
        else {
          if (SIZE(current_instruction().products) < 2)
            raise_error << maybe(current_recipe_name()) << "no ingredient to save in " << current_instruction().products.at(0).original_string << '\n' << end();
          if (current_instruction().products.empty()) break;
          products.resize(2);
          // pad the first product with sufficient zeros to match its type
          long long int size = size_of(current_instruction().products.at(0));
          for (long long int i = 0; i < size; ++i)
            products.at(0).push_back(0);
          products.at(1).push_back(0);
        }
        break;
      }

      case REWIND_INGREDIENTS: {
        current_call().next_ingredient_to_process = 0;
        break;
      }

      case INGREDIENT: {
        if (static_cast<long long int>(ingredients.at(0).at(0)) < SIZE(current_call().ingredient_atoms)) {
          current_call().next_ingredient_to_process = ingredients.at(0).at(0);
          products.push_back(
              current_call().ingredient_atoms.at(current_call().next_ingredient_to_process));
          assert(SIZE(products) == 1);  products.resize(2);  // push a new vector
          products.at(1).push_back(1);
          ++current_call().next_ingredient_to_process;
        }
        else {
          if (SIZE(current_instruction().products) > 1) {
            products.resize(2);
            products.at(0).push_back(0);  // todo: will fail noisily if we try to read a compound value
            products.at(1).push_back(0);
          }
        }
        break;
      }

      case REPLY: {
        // Starting Reply
        try_reclaim_locals();

        if (Trace_stream) {
          trace(9999, "trace") << "reply: decrementing callstack depth from " << Trace_stream->callstack_depth << end();
          --Trace_stream->callstack_depth;
          if (Trace_stream->callstack_depth < 0) {
            Current_routine->calls.clear();
            goto stop_running_current_routine;
          }
        }
        Current_routine->calls.pop_front();
        // just in case 'main' returns a value, drop it for now
        if (Current_routine->calls.empty()) goto stop_running_current_routine;
        const instruction& caller_instruction = current_instruction();
        for (long long int i = 0; i < SIZE(caller_instruction.products); ++i)
          trace(9998, "run") << "result " << i << " is " << to_string(ingredients.at(i)) << end();

        // make reply products available to caller
        copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
        // End Reply
        break;  // continue to process rest of *caller* instruction
      }

      case ALLOCATE: {
        // compute the space we need
        long long int size = ingredients.at(0).at(0);
        if (SIZE(ingredients) > 1) {
          // array
          trace(9999, "mem") << "array size is " << ingredients.at(1).at(0) << end();
          size = /*space for length*/1 + size*ingredients.at(1).at(0);
        }
        // include space for refcount
        size++;
        trace(9999, "mem") << "allocating size " << size << end();
      //?   Total_alloc += size;
      //?   Num_alloc++;
        // compute the region of memory to return
        // really crappy at the moment
        if (get_or_insert(Free_list, size)) {
          trace(9999, "abandon") << "picking up space from free-list of size " << size << end();
          long long int result = get_or_insert(Free_list, size);
          put(Free_list, size, get_or_insert(Memory, result));
          for (long long int curr = result+1; curr < result+size; ++curr) {
            if (get_or_insert(Memory, curr) != 0) {
              raise_error << maybe(current_recipe_name()) << "memory in free list was not zeroed out: " << curr << '/' << result << "; somebody wrote to us after free!!!\n" << end();
              break;  // always fatal
            }
          }
          if (SIZE(current_instruction().ingredients) > 1)
            put(Memory, result+/*skip refcount*/1, ingredients.at(1).at(0));
          else
            put(Memory, result, 0);
          products.resize(1);
          products.at(0).push_back(result);
          break;
        }

        ensure_space(size);
        const long long int result = Current_routine->alloc;
        trace(9999, "mem") << "new alloc: " << result << end();
        // save result
        products.resize(1);
        products.at(0).push_back(result);
        // initialize allocated space
        for (long long int address = result; address < result+size; ++address)
          put(Memory, address, 0);
        // initialize array length
        if (SIZE(current_instruction().ingredients) > 1) {
          trace(9999, "mem") << "storing " << ingredients.at(1).at(0) << " in location " << result+/*skip refcount*/1 << end();
          put(Memory, result+/*skip refcount*/1, ingredients.at(1).at(0));
        }
        // bump
        Current_routine->alloc += size;
        // no support for reclaiming memory
        assert(Current_routine->alloc <= Current_routine->alloc_max);
        break;
      }

      case NEW: {
        if (is_literal_string(current_instruction().ingredients.at(0))) {
          products.resize(1);
          products.at(0).push_back(new_mu_string(current_instruction().ingredients.at(0).name));
          break;
        }

        raise << "no implementation for 'new'; why wasn't it translated to 'allocate'?\n" << end();
        break;
      }

      //? :(before "End Globals")
      //? long long int Total_alloc = 0;
      //? long long int Num_alloc = 0;
      //? long long int Total_free = 0;
      //? long long int Num_free = 0;
      //? :(before "End Setup")
      //? Total_alloc = Num_alloc = Total_free = Num_free = 0;
      //? :(before "End Teardown")
      //? cerr << Total_alloc << "/" << Num_alloc
      //?      << " vs " << Total_free << "/" << Num_free << '\n';
      //? cerr << SIZE(Memory) << '\n';

      case ABANDON: {
        long long int address = ingredients.at(0).at(0);
        trace(9999, "abandon") << "address to abandon is " << address << end();
        reagent types = current_instruction().ingredients.at(0);
        trace(9999, "abandon") << "value of ingredient is " << types.value << end();
        canonize(types);
        // lookup_memory without drop_one_lookup {
        trace(9999, "abandon") << "value of ingredient after canonization is " << types.value << end();
        long long int address_location = types.value;
        types.set_value(get_or_insert(Memory, types.value)+/*skip refcount*/1);
        drop_from_type(types, "address");
        drop_from_type(types, "shared");
        // }
        abandon(address, size_of(types)+/*refcount*/1);
        // clear the address
        trace(9999, "mem") << "resetting location " << address_location << end();
        put(Memory, address_location, 0);
        break;
      }

      case TO_LOCATION_ARRAY: {
        long long int array_size = SIZE(ingredients.at(0));
        long long int allocation_size = array_size + /*refcount*/1 + /*length*/1;
        ensure_space(allocation_size);
        const long long int result = Current_routine->alloc;
        products.resize(1);
        products.at(0).push_back(result);
        // initialize array refcount
        put(Memory, result, 0);
        // initialize array length
        put(Memory, result+1, array_size);
        // now copy over data
        for (long long int i = 0; i < array_size; ++i)
          put(Memory, result+2+i, ingredients.at(0).at(i));
        break;
      }

      case RUN: {
        assert(Name[Next_recipe_ordinal].empty());
        ostringstream tmp;
        tmp << "recipe run_" << Next_recipe_ordinal << " [ " << current_instruction().ingredients.at(0).name << " ]";
      //?   cerr << tmp.str() << '\n';
      //?   cerr << "before load\n";
        vector<recipe_ordinal> tmp_recipe = load(tmp.str());
      //?   cerr << "before bind\n";
        bind_special_scenario_names(tmp_recipe.at(0));
      //?   cerr << "before transform\n";
        transform_all();
        // There's a restriction on the number of variables 'run' can use, so that
        // it can avoid colliding with the dynamic allocator in case it doesn't
        // initialize a default-space.
        assert(Name[tmp_recipe.at(0)][""] < Max_variables_in_scenarios);

      //?   cerr << "end\n";
        if (Trace_stream) {
          ++Trace_stream->callstack_depth;
          trace(9998, "trace") << "run: incrementing callstack depth to " << Trace_stream->callstack_depth << end();
          assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
        }
        Current_routine->calls.push_front(call(tmp_recipe.at(0)));
        continue;  // not done with caller; don't increment current_step_index()
      }

      // Some variables for fake resources always get special addresses in
      // scenarios.
      case MEMORY_SHOULD_CONTAIN: {
        if (!Passed) break;
        check_memory(current_instruction().ingredients.at(0).name);
        break;
      }

      case TRACE_SHOULD_CONTAIN: {
        if (!Passed) break;
        check_trace(current_instruction().ingredients.at(0).name);
        break;
      }

      case TRACE_SHOULD_NOT_CONTAIN: {
        if (!Passed) break;
        check_trace_missing(current_instruction().ingredients.at(0).name);
        break;
      }

      case CHECK_TRACE_COUNT_FOR_LABEL: {
        if (!Passed) break;
        long long int expected_count = ingredients.at(0).at(0);
        string label = current_instruction().ingredients.at(1).name;
        long long int count = trace_count(label);
        if (count != expected_count) {
          if (Current_scenario && !Scenario_testing_scenario) {
            // genuine test in a mu file
            raise_error << "\nF - " << Current_scenario->name << ": " << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label " << label << " in trace: ";
            DUMP(label);
            raise_error;
          }
          else {
            // just testing scenario support
            raise_error << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label " << label << " in trace\n" << end();
          }
          if (!Scenario_testing_scenario) {
            Passed = false;
            ++Num_failures;
          }
        }
        break;
      }

      case NEXT_INGREDIENT_WITHOUT_TYPECHECKING: {
        assert(!Current_routine->calls.empty());
        if (current_call().next_ingredient_to_process < SIZE(current_call().ingredient_atoms)) {
          products.push_back(
              current_call().ingredient_atoms.at(current_call().next_ingredient_to_process));
          assert(SIZE(products) == 1);  products.resize(2);  // push a new vector
          products.at(1).push_back(1);
          ++current_call().next_ingredient_to_process;
        }
        else {
          products.resize(2);
          // pad the first product with sufficient zeros to match its type
          long long int size = size_of(current_instruction().products.at(0));
          for (long long int i = 0; i < size; ++i)
            products.at(0).push_back(0);
          products.at(1).push_back(0);
        }
        break;
      }


      case CALL: {
        // Begin Call
        if (Trace_stream) {
          ++Trace_stream->callstack_depth;
          trace("trace") << "indirect 'call': incrementing callstack depth to " << Trace_stream->callstack_depth << end();
          assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
        }
        const instruction& caller_instruction = current_instruction();
        Current_routine->calls.push_front(call(ingredients.at(0).at(0)));
        ingredients.erase(ingredients.begin());  // drop the callee
        finish_call_housekeeping(caller_instruction, ingredients);
        continue;
      }


      case START_RUNNING: {
        routine* new_routine = new routine(ingredients.at(0).at(0));
        new_routine->parent_index = Current_routine_index;
        // populate ingredients
        for (long long int i = 1; i < SIZE(current_instruction().ingredients); ++i) {
          new_routine->calls.front().ingredient_atoms.push_back(ingredients.at(i));
          reagent ingredient = current_instruction().ingredients.at(i);
          canonize_type(ingredient);
          new_routine->calls.front().ingredients.push_back(ingredient);
        }
        Routines.push_back(new_routine);
        products.resize(1);
        products.at(0).push_back(new_routine->id);
        break;
      }

      case ROUTINE_STATE: {
        long long int id = ingredients.at(0).at(0);
        long long int result = -1;
        for (long long int i = 0; i < SIZE(Routines); ++i) {
          if (Routines.at(i)->id == id) {
            result = Routines.at(i)->state;
            break;
          }
        }
        products.resize(1);
        products.at(0).push_back(result);
        break;
      }


      case RESTART: {
        long long int id = ingredients.at(0).at(0);
        for (long long int i = 0; i < SIZE(Routines); ++i) {
          if (Routines.at(i)->id == id) {
            Routines.at(i)->state = RUNNING;
            break;
          }
        }
        break;
      }

      case STOP: {
        long long int id = ingredients.at(0).at(0);
        for (long long int i = 0; i < SIZE(Routines); ++i) {
          if (Routines.at(i)->id == id) {
            Routines.at(i)->state = COMPLETED;
            break;
          }
        }
        break;
      }

      case _DUMP_ROUTINES: {
        for (long long int i = 0; i < SIZE(Routines); ++i) {
          cerr << i << ": " << Routines.at(i)->id << ' ' << Routines.at(i)->state << ' ' << Routines.at(i)->parent_index << '\n';
        }
        break;
      }


      case LIMIT_TIME: {
        long long int id = ingredients.at(0).at(0);
        for (long long int i = 0; i < SIZE(Routines); ++i) {
          if (Routines.at(i)->id == id) {
            Routines.at(i)->limit = ingredients.at(1).at(0);
            break;
          }
        }
        break;
      }


      case WAIT_FOR_LOCATION: {
        reagent loc = current_instruction().ingredients.at(0);
        canonize(loc);
        Current_routine->state = WAITING;
        Current_routine->waiting_on_location = loc.value;
        Current_routine->old_value_of_waiting_location = get_or_insert(Memory, loc.value);
        trace(9998, "run") << "waiting for location " << loc.value << " to change from " << no_scientific(get_or_insert(Memory, loc.value)) << end();
        break;
      }


      case WAIT_FOR_ROUTINE: {
        if (ingredients.at(0).at(0) == Current_routine->id) {
          raise_error << maybe(current_recipe_name()) << "routine can't wait for itself! " << to_string(current_instruction()) << '\n' << end();
          break;
        }
        Current_routine->state = WAITING;
        Current_routine->waiting_on_routine = ingredients.at(0).at(0);
        trace(9998, "run") << "waiting for routine " << ingredients.at(0).at(0) << end();
        break;
      }

      case SWITCH: {
        long long int id = some_other_running_routine();
        if (id) {
          assert(id != Current_routine->id);
          Current_routine->state = WAITING;
          Current_routine->waiting_on_routine = id;
        }
        break;
      }

      case RANDOM: {
        // todo: limited range of numbers, might be imperfectly random
        // todo: thread state in extra ingredients and products
        products.resize(1);
        products.at(0).push_back(rand());
        break;
      }

      case MAKE_RANDOM_NONDETERMINISTIC: {
        srand(time(NULL));
        break;
      }

      case ROUND: {
        products.resize(1);
        products.at(0).push_back(rint(ingredients.at(0).at(0)));
        break;
      }

      case HASH: {
        reagent input = current_instruction().ingredients.at(0);  // copy
        products.resize(1);
        products.at(0).push_back(hash(0, input));
        break;
      }


      case HASH_OLD: {
        string input = read_mu_string(ingredients.at(0).at(0));
        size_t h = 0 ;

        for (long long int i = 0; i < SIZE(input); ++i) {
          h += static_cast<size_t>(input.at(i));
          h += (h<<10);
          h ^= (h>>6);

          h += (h<<3);
          h ^= (h>>11);
          h += (h<<15);
        }

        products.resize(1);
        products.at(0).push_back(h);
        break;
      }

      case OPEN_CONSOLE: {
        tb_init();
        Display_row = Display_column = 0;
        long long int width = tb_width();
        long long int height = tb_height();
        if (width > 222 || height > 222) tb_shutdown();
        if (width > 222)
          raise_error << "sorry, mu doesn't support windows wider than 222 characters. Please resize your window.\n" << end();
        if (height > 222)
          raise_error << "sorry, mu doesn't support windows taller than 222 characters. Please resize your window.\n" << end();
        break;
      }

      case CLOSE_CONSOLE: {
        tb_shutdown();
        break;
      }

      case CLEAR_DISPLAY: {
        tb_clear();
        Display_row = Display_column = 0;
        break;
      }

      case SYNC_DISPLAY: {
        tb_sync();
        break;
      }

      case CLEAR_LINE_ON_DISPLAY: {
        long long int width = tb_width();
        for (long long int x = Display_column; x < width; ++x) {
          tb_change_cell(x, Display_row, ' ', TB_WHITE, TB_BLACK);
        }
        tb_set_cursor(Display_column, Display_row);
        if (Autodisplay) tb_present();
        break;
      }

      case PRINT_CHARACTER_TO_DISPLAY: {
        int h=tb_height(), w=tb_width();
        long long int height = (h >= 0) ? h : 0;
        long long int width = (w >= 0) ? w : 0;
        long long int c = ingredients.at(0).at(0);
        int color = TB_BLACK;
        if (SIZE(ingredients) > 1) {
          color = ingredients.at(1).at(0);
        }
        int bg_color = TB_BLACK;
        if (SIZE(ingredients) > 2) {
          bg_color = ingredients.at(2).at(0);
          if (bg_color == 0) bg_color = TB_BLACK;
        }
        tb_change_cell(Display_column, Display_row, c, color, bg_color);
        if (c == '\n' || c == '\r') {
          if (Display_row < height-1) {
            Display_column = 0;
            ++Display_row;
            tb_set_cursor(Display_column, Display_row);
            if (Autodisplay) tb_present();
          }
          break;
        }
        if (c == '\b') {
          if (Display_column > 0) {
            tb_change_cell(Display_column-1, Display_row, ' ', color, bg_color);
            --Display_column;
            tb_set_cursor(Display_column, Display_row);
            if (Autodisplay) tb_present();
          }
          break;
        }
        if (Display_column < width-1) {
          ++Display_column;
          tb_set_cursor(Display_column, Display_row);
        }
        if (Autodisplay) tb_present();
        break;
      }

      case CURSOR_POSITION_ON_DISPLAY: {
        products.resize(2);
        products.at(0).push_back(Display_row);
        products.at(1).push_back(Display_column);
        break;
      }

      case MOVE_CURSOR_ON_DISPLAY: {
        Display_row = ingredients.at(0).at(0);
        Display_column = ingredients.at(1).at(0);
        tb_set_cursor(Display_column, Display_row);
        if (Autodisplay) tb_present();
        break;
      }

      case MOVE_CURSOR_DOWN_ON_DISPLAY: {
        int h=tb_height();
        long long int height = (h >= 0) ? h : 0;
        if (Display_row < height-1) {
          Display_row++;
          tb_set_cursor(Display_column, Display_row);
          if (Autodisplay) tb_present();
        }
        break;
      }

      case MOVE_CURSOR_UP_ON_DISPLAY: {
        if (Display_row > 0) {
          Display_row--;
          tb_set_cursor(Display_column, Display_row);
          if (Autodisplay) tb_present();
        }
        break;
      }

      case MOVE_CURSOR_RIGHT_ON_DISPLAY: {
        int w=tb_width();
        long long int width = (w >= 0) ? w : 0;
        if (Display_column < width-1) {
          Display_column++;
          tb_set_cursor(Display_column, Display_row);
          if (Autodisplay) tb_present();
        }
        break;
      }

      case MOVE_CURSOR_LEFT_ON_DISPLAY: {
        if (Display_column > 0) {
          Display_column--;
          tb_set_cursor(Display_column, Display_row);
          if (Autodisplay) tb_present();
        }
        break;
      }

      case DISPLAY_WIDTH: {
        products.resize(1);
        products.at(0).push_back(tb_width());
        break;
      }

      case DISPLAY_HEIGHT: {
        products.resize(1);
        products.at(0).push_back(tb_height());
        break;
      }

      case HIDE_CURSOR_ON_DISPLAY: {
        tb_set_cursor(TB_HIDE_CURSOR, TB_HIDE_CURSOR);
        break;
      }

      case SHOW_CURSOR_ON_DISPLAY: {
        tb_set_cursor(Display_row, Display_column);
        break;
      }

      case HIDE_DISPLAY: {
        Autodisplay = false;
        break;
      }

      case SHOW_DISPLAY: {
        Autodisplay = true;
        tb_present();
        break;
      }


      case WAIT_FOR_SOME_INTERACTION: {
        tb_event event;
        tb_poll_event(&event);
        break;
      }

      case CHECK_FOR_INTERACTION: {
        products.resize(2);  // result and status
        tb_event event;
        int event_type = tb_peek_event(&event, 5/*ms*/);
        if (event_type == TB_EVENT_KEY && event.ch) {
          products.at(0).push_back(/*text event*/0);
          products.at(0).push_back(event.ch);
          products.at(0).push_back(0);
          products.at(0).push_back(0);
          products.at(1).push_back(/*found*/true);
          break;
        }
        // treat keys within ascii as unicode characters
        if (event_type == TB_EVENT_KEY && event.key < 0xff) {
          products.at(0).push_back(/*text event*/0);
          if (event.key == TB_KEY_CTRL_C) {
            tb_shutdown();
            exit(1);
          }
          if (event.key == TB_KEY_BACKSPACE2) event.key = TB_KEY_BACKSPACE;
          if (event.key == TB_KEY_CARRIAGE_RETURN) event.key = TB_KEY_NEWLINE;
          products.at(0).push_back(event.key);
          products.at(0).push_back(0);
          products.at(0).push_back(0);
          products.at(1).push_back(/*found*/true);
          break;
        }
        // keys outside ascii aren't unicode characters but arbitrary termbox inventions
        if (event_type == TB_EVENT_KEY) {
          products.at(0).push_back(/*keycode event*/1);
          products.at(0).push_back(event.key);
          products.at(0).push_back(0);
          products.at(0).push_back(0);
          products.at(1).push_back(/*found*/true);
          break;
        }
        if (event_type == TB_EVENT_MOUSE) {
          products.at(0).push_back(/*touch event*/2);
          products.at(0).push_back(event.key);  // which button, etc.
          products.at(0).push_back(event.y);  // row
          products.at(0).push_back(event.x);  // column
          products.at(1).push_back(/*found*/true);
          break;
        }
        if (event_type == TB_EVENT_RESIZE) {
          products.at(0).push_back(/*resize event*/3);
          products.at(0).push_back(event.w);  // width
          products.at(0).push_back(event.h);  // height
          products.at(0).push_back(0);
          products.at(1).push_back(/*found*/true);
          break;
        }
        assert(event_type == 0);
        products.at(0).push_back(0);
        products.at(0).push_back(0);
        products.at(0).push_back(0);
        products.at(0).push_back(0);
        products.at(1).push_back(/*found*/false);
        break;
      }

      case INTERACTIONS_LEFT: {
        products.resize(1);
        products.at(0).push_back(tb_event_ready());
        break;
      }


      case CLEAR_DISPLAY_FROM: {
        // todo: error checking
        int row = ingredients.at(0).at(0);
        int column = ingredients.at(1).at(0);
        int left = ingredients.at(2).at(0);
        int right = ingredients.at(3).at(0);
        int height=tb_height();
        for (; row < height; ++row, column=left) {  // start column from left in every inner loop except first
          for (; column <= right; ++column) {
            tb_change_cell(column, row, ' ', TB_WHITE, TB_BLACK);
          }
        }
        if (Autodisplay) tb_present();
        break;
      }

      case SCREEN_SHOULD_CONTAIN: {
      //?   cerr << SIZE(get(Recipe_variants, "insert")) << '\n';
      //?   cerr << debug_string(get(Recipe, get(Recipe_ordinal, "insert_4"))) << '\n';
        if (!Passed) break;
        assert(scalar(ingredients.at(0)));
        check_screen(current_instruction().ingredients.at(0).name, -1);
        break;
      }

      case SCREEN_SHOULD_CONTAIN_IN_COLOR: {
        if (!Passed) break;
        assert(scalar(ingredients.at(0)));
        assert(scalar(ingredients.at(1)));
        check_screen(current_instruction().ingredients.at(1).name, ingredients.at(0).at(0));
        break;
      }

      case _DUMP_SCREEN: {
        dump_screen();
        break;
      }

      case ASSUME_CONSOLE: {
        // create a temporary recipe just for parsing; it won't contain valid instructions
        istringstream in("[" + current_instruction().ingredients.at(0).name + "]");
        recipe r;
        slurp_body(in, r);
        long long int num_events = count_events(r);
        // initialize the events like in new-fake-console
        long long int size = /*space for refcount*/1 + /*space for length*/1 + num_events*size_of_event();
        ensure_space(size);
        long long int event_data_address = Current_routine->alloc;
        // store length
        put(Memory, Current_routine->alloc+/*skip refcount*/1, num_events);
        Current_routine->alloc += /*skip refcount and length*/2;
        for (long long int i = 0; i < SIZE(r.steps); ++i) {
          const instruction& curr = r.steps.at(i);
          if (curr.name == "left-click") {
            trace(9999, "mem") << "storing 'left-click' event starting at " << Current_routine->alloc << end();
            put(Memory, Current_routine->alloc, /*tag for 'touch-event' variant of 'event' exclusive-container*/2);
            put(Memory, Current_routine->alloc+1+/*offset of 'type' in 'mouse-event'*/0, TB_KEY_MOUSE_LEFT);
            put(Memory, Current_routine->alloc+1+/*offset of 'row' in 'mouse-event'*/1, to_integer(curr.ingredients.at(0).name));
            put(Memory, Current_routine->alloc+1+/*offset of 'column' in 'mouse-event'*/2, to_integer(curr.ingredients.at(1).name));
            Current_routine->alloc += size_of_event();
          }
          else if (curr.name == "press") {
            trace(9999, "mem") << "storing 'press' event starting at " << Current_routine->alloc << end();
            string key = curr.ingredients.at(0).name;
            if (is_integer(key))
              put(Memory, Current_routine->alloc+1, to_integer(key));
            else if (contains_key(Key, key))
              put(Memory, Current_routine->alloc+1, Key[key]);
            else
              raise_error << "assume-console: can't press " << key << '\n' << end();
            if (get_or_insert(Memory, Current_routine->alloc+1) < 256)
              // these keys are in ascii
              put(Memory, Current_routine->alloc, /*tag for 'text' variant of 'event' exclusive-container*/0);
            else {
              // distinguish from unicode
              put(Memory, Current_routine->alloc, /*tag for 'keycode' variant of 'event' exclusive-container*/1);
            }
            Current_routine->alloc += size_of_event();
          }
          // End Event Handlers
          else {
            // keyboard input
            assert(curr.name == "type");
            trace(9999, "mem") << "storing 'type' event starting at " << Current_routine->alloc << end();
            const string& contents = curr.ingredients.at(0).name;
            const char* raw_contents = contents.c_str();
            long long int num_keyboard_events = unicode_length(contents);
            long long int curr = 0;
            for (long long int i = 0; i < num_keyboard_events; ++i) {
              trace(9999, "mem") << "storing 'text' tag at " << Current_routine->alloc << end();
              put(Memory, Current_routine->alloc, /*tag for 'text' variant of 'event' exclusive-container*/0);
              uint32_t curr_character;
              assert(curr < SIZE(contents));
              tb_utf8_char_to_unicode(&curr_character, &raw_contents[curr]);
              trace(9999, "mem") << "storing character " << curr_character << " at " << Current_routine->alloc+1 << end();
              put(Memory, Current_routine->alloc+/*skip exclusive container tag*/1, curr_character);
              curr += tb_utf8_char_length(raw_contents[curr]);
              Current_routine->alloc += size_of_event();
            }
          }
        }
        assert(Current_routine->alloc == event_data_address+size);
        // wrap the array of events in a console object
        ensure_space(size_of_console());
        put(Memory, CONSOLE, Current_routine->alloc);
        trace(9999, "mem") << "storing console in " << Current_routine->alloc << end();
        Current_routine->alloc += size_of_console();
        long long int console_address = get_or_insert(Memory, CONSOLE);
        trace(9999, "mem") << "storing console data in " << console_address+2 << end();
        put(Memory, console_address+/*skip refcount*/1+/*offset of 'data' in container 'events'*/1, event_data_address);
        break;
      }

      case REPLACE_IN_CONSOLE: {
        assert(scalar(ingredients.at(0)));
        if (!get_or_insert(Memory, CONSOLE)) {
          raise_error << "console not initialized\n" << end();
          break;
        }
        long long int console_address = get_or_insert(Memory, CONSOLE);
        long long int console_data = get_or_insert(Memory, console_address+1);
        long long int size = get_or_insert(Memory, console_data);  // array size
        for (long long int i = 0, curr = console_data+1; i < size; ++i, curr+=size_of_event()) {
          if (get_or_insert(Memory, curr) != /*text*/0) continue;
          if (get_or_insert(Memory, curr+1) != ingredients.at(0).at(0)) continue;
          for (long long int n = 0; n < size_of_event(); ++n)
            put(Memory, curr+n, ingredients.at(1).at(n));
        }
        break;
      }

      case _BROWSE_TRACE: {
        start_trace_browser();
        break;
      }

      case RUN_INTERACTIVE: {
        bool new_code_pushed_to_stack = run_interactive(ingredients.at(0).at(0));
        if (!new_code_pushed_to_stack) {
          products.resize(5);
          products.at(0).push_back(0);
          products.at(1).push_back(trace_error_warning_contents());
          products.at(2).push_back(0);
          products.at(3).push_back(trace_app_contents());
          products.at(4).push_back(1);  // completed
          run_code_end();
          break;  // done with this instruction
        }
        else {
          continue;  // not done with caller; don't increment current_step_index()
        }
      }

      case _START_TRACKING_PRODUCTS: {
        Track_most_recent_products = true;
        break;
      }

      case _STOP_TRACKING_PRODUCTS: {
        Track_most_recent_products = false;
        break;
      }

      case _MOST_RECENT_PRODUCTS: {
        products.resize(1);
        products.at(0).push_back(new_mu_string(Most_recent_products));
        break;
      }

      case SAVE_ERRORS_WARNINGS: {
        products.resize(1);
        products.at(0).push_back(trace_error_warning_contents());
        break;
      }

      case SAVE_APP_TRACE: {
        products.resize(1);
        products.at(0).push_back(trace_app_contents());
        break;
      }

      case _CLEANUP_RUN_INTERACTIVE: {
        run_code_end();
        break;
      }

      case RELOAD: {
      //?   cerr << "== reload\n";
        // clear any containers in advance
        for (long long int i = 0; i < SIZE(Recently_added_types); ++i) {
          if (!contains_key(Type, Recently_added_types.at(i))) continue;
          Type_ordinal.erase(get(Type, Recently_added_types.at(i)).name);
          Type.erase(Recently_added_types.at(i));
        }
        for (map<string, vector<recipe_ordinal> >::iterator p = Recipe_variants.begin(); p != Recipe_variants.end(); ++p) {
      //?     cerr << p->first << ":\n";
          vector<recipe_ordinal>& variants = p->second;
          for (long long int i = 0; i < SIZE(p->second); ++i) {
            if (variants.at(i) == -1) continue;
            if (find(Recently_added_shape_shifting_recipes.begin(), Recently_added_shape_shifting_recipes.end(), variants.at(i)) != Recently_added_shape_shifting_recipes.end()) {
      //?         cerr << "  " << variants.at(i) << ' ' << get(Recipe, variants.at(i)).name << '\n';
              variants.at(i) = -1;  // ghost
            }
          }
        }
        for (long long int i = 0; i < SIZE(Recently_added_shape_shifting_recipes); ++i) {
          Recipe_ordinal.erase(get(Recipe, Recently_added_shape_shifting_recipes.at(i)).name);
          Recipe.erase(Recently_added_shape_shifting_recipes.at(i));
        }
        Recently_added_shape_shifting_recipes.clear();
        string code = read_mu_string(ingredients.at(0).at(0));
        run_code_begin(/*snapshot_recently_added_recipes*/false);
        routine* save_current_routine = Current_routine;
        Current_routine = NULL;
        vector<recipe_ordinal> recipes_reloaded = load(code);
        // clear a few things from previous runs
        // ad hoc list; we've probably missed a few
        for (long long int i = 0; i < SIZE(recipes_reloaded); ++i)
          Name.erase(recipes_reloaded.at(i));
        transform_all();
        Trace_stream->newline();  // flush trace
        Current_routine = save_current_routine;
        products.resize(1);
        products.at(0).push_back(trace_error_warning_contents());
        run_code_end();  // wait until we're done with the trace contents
      //?   cerr << "reload done\n";
        break;
      }

      case RESTORE: {
        string filename;
        if (is_literal_string(current_instruction().ingredients.at(0))) {
          filename = current_instruction().ingredients.at(0).name;
        }
        else if (is_mu_string(current_instruction().ingredients.at(0))) {
          filename = read_mu_string(ingredients.at(0).at(0));
        }
        if (Current_scenario) {
          // do nothing in tests
          products.resize(1);
          products.at(0).push_back(0);
          break;
        }
        string contents = slurp("lesson/"+filename);
        products.resize(1);
        if (contents.empty())
          products.at(0).push_back(0);
        else
          products.at(0).push_back(new_mu_string(contents));
        break;
      }

      case SAVE: {
        if (Current_scenario) break;  // do nothing in tests
        string filename;
        if (is_literal_string(current_instruction().ingredients.at(0))) {
          filename = current_instruction().ingredients.at(0).name;
        }
        else if (is_mu_string(current_instruction().ingredients.at(0))) {
          filename = read_mu_string(ingredients.at(0).at(0));
        }
        ofstream fout(("lesson/"+filename).c_str());
        string contents = read_mu_string(ingredients.at(1).at(0));
        fout << contents;
        fout.close();
        if (!exists("lesson/.git")) break;
        // bug in git: git diff -q messes up --exit-code
        // explicitly say '--all' for git 1.9
        int status = system("cd lesson; git add --all .; git diff HEAD --exit-code >/dev/null || git commit -a -m . >/dev/null");
        if (status != 0)
          raise_error << "error in commit: contents " << contents << '\n' << end();
        break;
      }

      // End Primitive Recipe Implementations
      default: {
        const instruction& call_instruction = current_instruction();
        if (Recipe.find(current_instruction().operation) == Recipe.end()) {  // duplicate from Checks
          // stop running this instruction immediately
          ++current_step_index();
          continue;
        }
        // not a primitive; look up the book of recipes
        if (Trace_stream) {
          ++Trace_stream->callstack_depth;
          trace(9999, "trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end();
          assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
        }
        Current_routine->calls.push_front(call(current_instruction().operation));
        finish_call_housekeeping(call_instruction, ingredients);
        continue;  // not done with caller; don't increment step_index of caller
      }
    }
    if (SIZE(products) < SIZE(current_instruction().products)) {
      raise_error << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products! " << to_string(current_instruction()) << '\n' << end();
    }
    else {
      for (long long int i = 0; i < SIZE(current_instruction().products); ++i) {
        write_memory(current_instruction().products.at(i), products.at(i));
      }
    }
    if (Track_most_recent_products) {
      track_most_recent_products(current_instruction(), products);
    }
    // End of Instruction
    ++current_step_index();
  }
  stop_running_current_routine:;
}

bool should_copy_ingredients() {
  recipe_ordinal r = current_instruction().operation;
  if (r == CREATE_ARRAY || r == INDEX || r == INDEX_ADDRESS || r == LENGTH)
    return false;

  // End should_copy_ingredients Special-cases
  return true;
}


inline long long int& current_step_index() {
  assert(!Current_routine->calls.empty());
  return current_call().running_step_index;
}

inline const string& current_recipe_name() {
  assert(!Current_routine->calls.empty());
  return get(Recipe, current_call().running_recipe).name;
}

inline const instruction& current_instruction() {
  assert(!Current_routine->calls.empty());
  return to_instruction(current_call());
}

inline bool routine::completed() const {
  return calls.empty();
}

inline const vector<instruction>& routine::steps() const {
  assert(!calls.empty());
  return get(Recipe, calls.front().running_recipe).steps;
}



void run_main(int argc, char* argv[]) {
  recipe_ordinal r = get(Recipe_ordinal, "main");
  assert(r);
  routine* main_routine = new routine(r);
  // pass in commandline args as ingredients to main
  // todo: test this
  Current_routine = main_routine;
  for (long long int i = 1; i < argc; ++i) {
    vector<double> arg;
    arg.push_back(new_mu_string(argv[i]));
    current_call().ingredient_atoms.push_back(arg);
  }
  run(main_routine);
}



void dump_profile() {
  for (map<string, long long int>::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) {
    cerr << p->first << ": " << p->second << '\n';
  }
  cerr << "== locations read\n";
  for (map<string, long long int>::iterator p = Locations_read.begin(); p != Locations_read.end(); ++p) {
    cerr << p->first << ": " << p->second << '\n';
  }
  cerr << "== locations read by instruction\n";
  for (map<string, long long int>::iterator p = Locations_read_by_instruction.begin(); p != Locations_read_by_instruction.end(); ++p) {
    cerr << p->first << ": " << p->second << '\n';
  }
}
void cleanup_main() {
  if (!Trace_file.empty() && Trace_stream) {
    ofstream fout((Trace_dir+Trace_file).c_str());
    fout << Trace_stream->readable_contents("");
    fout.close();
  }
}
void load_permanently(string filename) {
  if (is_directory(filename)) {
    load_all_permanently(filename);
    return;
  }
  ifstream fin(filename.c_str());
  fin.peek();
  if (!fin) {
    raise_error << "no such file " << filename << '\n' << end();
    return;
  }
  fin >> std::noskipws;
  trace(9990, "load") << "=== " << filename << end();
  load(fin);
  fin.close();
  // freeze everything so it doesn't get cleared by tests
  Recently_added_recipes.clear();
  Recently_added_types.clear();
  // End load_permanently.
}

bool is_directory(string path) {
  struct stat info;
  if (stat(path.c_str(), &info)) return false;  // error
  return info.st_mode & S_IFDIR;
}

void load_all_permanently(string dir) {
  dirent** files;
  int num_files = scandir(dir.c_str(), &files, NULL, alphasort);
  for (int i = 0; i < num_files; ++i) {
    string curr_file = files[i]->d_name;
    if (!isdigit(curr_file.at(0))) continue;
    load_permanently(dir+'/'+curr_file);
    free(files[i]);
    files[i] = NULL;
  }
  free(files);
}
vector<double> read_memory(reagent x) {
  if (x.name == "number-of-locals") {
    vector<double> result;
    result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
    if (result.back() == 0)
      raise_error << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
    return result;
  }
  if (x.name == "default-space") {
    vector<double> result;
    result.push_back(current_call().default_space);
    return result;
  }


  vector<double> result;
  if (is_literal(x)) {
    result.push_back(x.value);
    return result;
  }
  canonize(x);

  long long int base = x.value;
  long long int size = size_of(x);
  for (long long int offset = 0; offset < size; ++offset) {
    double val = get_or_insert(Memory, base+offset);
    trace(9999, "mem") << "location " << base+offset << " is " << no_scientific(val) << end();
    result.push_back(val);
  }
  return result;
}

void write_memory(reagent x, vector<double> data) {
  if (x.name == "global-space") {
    if (!scalar(data)
        || !x.type
        || x.type->value != get(Type_ordinal, "address")
        || !x.type->right
        || x.type->right->value != get(Type_ordinal, "shared")
        || !x.type->right->right
        || x.type->right->right->value != get(Type_ordinal, "array")
        || !x.type->right->right->right
        || x.type->right->right->right->value != get(Type_ordinal, "location")
        || x.type->right->right->right->right) {
      raise_error << maybe(current_recipe_name()) << "'global-space' should be of type address:shared:array:location, but tried to write " << to_string(data) << '\n' << end();
    }
    if (Current_routine->global_space)
      raise_error << "routine already has a global-space; you can't over-write your globals" << end();
    Current_routine->global_space = data.at(0);
    return;
  }

  if (x.name == "number-of-locals") {
    raise_error << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
    return;
  }


  if (x.name == "default-space") {
    if (!scalar(data)
        || !x.type
        || x.type->value != get(Type_ordinal, "address")
        || !x.type->right
        || x.type->right->value != get(Type_ordinal, "shared")
        || !x.type->right->right
        || x.type->right->right->value != get(Type_ordinal, "array")
        || !x.type->right->right->right
        || x.type->right->right->right->value != get(Type_ordinal, "location")
        || x.type->right->right->right->right) {
      raise_error << maybe(current_recipe_name()) << "'default-space' should be of type address:shared:array:location, but tried to write " << to_string(data) << '\n' << end();
    }
    current_call().default_space = data.at(0);
    return;
  }

  if (!x.type) {
    raise_error << "can't write to " << to_string(x) << "; no type\n" << end();
    return;
  }
  if (is_dummy(x)) return;
  if (is_literal(x)) return;
  canonize(x);
  if (x.value == 0) {
    raise_error << "can't write to location 0 in '" << to_string(current_instruction()) << "'\n" << end();
    return;
  }

  long long int base = x.value;
  if (base == 0) return;
  if (size_mismatch(x, data)) {
    raise_error << maybe(current_recipe_name()) << "size mismatch in storing to " << x.original_string << " (" << size_of(x.type) << " vs " << SIZE(data) << ") at '" << to_string(current_instruction()) << "'\n" << end();
    return;
  }
  if (x.type->value == get(Type_ordinal, "address")
      && x.type->right
      && x.type->right->value == get(Type_ordinal, "shared")) {
    // compute old address of x, as well as new address we want to write in
    long long int old_address = get_or_insert(Memory, x.value);
    assert(scalar(data));
    long long int new_address = data.at(0);
    // decrement refcount of old address
    if (old_address) {
      long long int old_refcount = get_or_insert(Memory, old_address);
      trace(9999, "mem") << "decrementing refcount of " << old_address << ": " << old_refcount << " -> " << (old_refcount-1) << end();
      put(Memory, old_address, old_refcount-1);
    }
    // perform the write
    trace(9999, "mem") << "storing " << no_scientific(data.at(0)) << " in location " << base << end();
    put(Memory, base, new_address);
    // increment refcount of new address
    if (new_address) {
      long long int new_refcount = get_or_insert(Memory, new_address);
      assert(new_refcount >= 0);  // == 0 only when new_address == old_address
      trace(9999, "mem") << "incrementing refcount of " << new_address << ": " << new_refcount << " -> " << (new_refcount+1) << end();
      put(Memory, new_address, new_refcount+1);
    }
    // abandon old address if necessary
    // do this after all refcount updates are done just in case old and new are identical
    assert(get_or_insert(Memory, old_address) >= 0);
    if (old_address && get_or_insert(Memory, old_address) == 0) {
      // lookup_memory without drop_one_lookup {
      trace(9999, "mem") << "automatically abandoning " << old_address << end();
      trace(9999, "mem") << "computing size to abandon at " << x.value << end();
      x.set_value(get_or_insert(Memory, x.value)+/*skip refcount*/1);
      drop_from_type(x, "address");
      drop_from_type(x, "shared");
      // }
      abandon(old_address, size_of(x)+/*refcount*/1);
    }
    return;
  }

  // End write_memory(reagent x, long long int base) Special-cases
  for (long long int offset = 0; offset < SIZE(data); ++offset) {
    assert(base+offset > 0);
    trace(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << base+offset << end();
    put(Memory, base+offset, data.at(offset));
  }
}

long long int size_of(const reagent& r) {
  if (r.type == NULL) return 0;
  if (r.type && r.type->value == get(Type_ordinal, "array")) {
    if (!r.type->right) {
      raise_error << maybe(current_recipe_name()) << "'" << r.original_string << "' is an array of what?\n" << end();
      return 1;
    }
  //?   trace(9999, "mem") << "computing size of array starting at " << r.value << end();
    return 1 + get_or_insert(Memory, r.value)*size_of(array_element(r.type));
  }


  // End size_of(reagent) Cases
  return size_of(r.type);
}
long long int size_of(const type_tree* type) {
  if (type == NULL) return 0;
  if (type->value == -1) {
    // error value, but we'll raise it elsewhere
    return 1;
  }
  if (type->value == 0) {
    assert(!type->left && !type->right);
    return 1;
  }
  if (!contains_key(Type, type->value)) {
    raise_error << "no such type " << type->value << '\n' << end();
    return 0;
  }
  type_info t = get(Type, type->value);
  if (t.kind == CONTAINER) {
    // size of a container is the sum of the sizes of its elements
    long long int result = 0;
    for (long long int i = 0; i < SIZE(t.elements); ++i) {
      // todo: strengthen assertion to disallow mutual type recursion
      if (t.elements.at(i).type->value == type->value) {
        raise_error << "container " << t.name << " can't include itself as a member\n" << end();
        return 0;
      }
      reagent tmp;
      tmp.type = new type_tree(*type);
      result += size_of(element_type(tmp, i));
    }
    return result;
  }

  if (t.kind == EXCLUSIVE_CONTAINER) {
    // size of an exclusive container is the size of its largest variant
    // (So like containers, it can't contain arrays.)
    long long int result = 0;
    for (long long int i = 0; i < t.size; ++i) {
      reagent tmp;
      tmp.type = new type_tree(*type);
      long long int size = size_of(variant_type(tmp, i));
      if (size > result) result = size;
    }
    // ...+1 for its tag.
    return result+1;
  }


  // End size_of(type) Cases
  return 1;
}

bool size_mismatch(const reagent& x, const vector<double>& data) {
  if (x.type == NULL) return true;
  if (x.type && x.type->value == get(Type_ordinal, "array")) return false;
  if (current_instruction().operation == MERGE
      && !current_instruction().products.empty()
      && current_instruction().products.at(0).type) {
    reagent x = current_instruction().products.at(0);
    canonize(x);
    if (get(Type, x.type->value).kind == EXCLUSIVE_CONTAINER) {
      return size_of(x) < SIZE(data);
    }
  }

  // End size_mismatch(x) Cases
//?   if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n';
  return size_of(x) != SIZE(data);
}

inline bool is_dummy(const reagent& x) {
  return x.name == "_";
}

inline bool is_literal(const reagent& r) {
  if (!r.type) return false;
  if (r.type->value == 0)
    assert(!r.type->left && !r.type->right);
  return r.type->value == 0;
}

inline bool scalar(const vector<long long int>& x) {
  return SIZE(x) == 1;
}
inline bool scalar(const vector<double>& x) {
  return SIZE(x) == 1;
}

// helper for tests
void run(string form) {
  vector<recipe_ordinal> tmp = load(form);
  transform_all();
  if (tmp.empty()) return;
  if (trace_count("error") > 0) return;
  run(tmp.front());
}

void test_run_label() {
  Trace_file = "run_label";
  run("recipe main [\n  +foo\n  1:number <- copy 23\n  2:number <- copy 1:number\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:number <- copy 23run: 2:number <- copy 1:number");
  CHECK_TRACE_DOESNT_CONTAIN("run: +foo");
}
void test_run_dummy() {
  Trace_file = "run_dummy";
  run("recipe main [\n  _ <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("run: _ <- copy 0");
}
void test_write_to_0_disallowed() {
  Trace_file = "write_to_0_disallowed";
  Hide_errors = true;
  run("recipe main [\n  0:number <- copy 34\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 0");
}
void test_comma_without_space() {
  Trace_file = "comma_without_space";
  run("recipe main [\n  1:number, 2:number <- copy 2,2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_space_without_comma() {
  Trace_file = "space_without_comma";
  run("recipe main [\n  1:number, 2:number <- copy 2 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_comma_before_space() {
  Trace_file = "comma_before_space";
  run("recipe main [\n  1:number, 2:number <- copy 2, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_comma_after_space() {
  Trace_file = "comma_after_space";
  run("recipe main [\n  1:number, 2:number <- copy 2 ,2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}

void check_instruction(const recipe_ordinal r) {
  trace(9991, "transform") << "--- perform checks for recipe " << get(Recipe, r).name << end();
//?   cerr << "--- perform checks for recipe " << get(Recipe, r).name << '\n';
  map<string, vector<type_ordinal> > metadata;
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    instruction& inst = get(Recipe, r).steps.at(i);
    if (inst.is_label) continue;
    switch (inst.operation) {
      // Primitive Recipe Checks
      case COPY: {
        if (SIZE(inst.products) != SIZE(inst.ingredients)) {
          raise_error << "ingredients and products should match in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!types_coercible(inst.products.at(i), inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "can't copy " << inst.ingredients.at(i).original_string << " to " << inst.products.at(i).original_string << "; types don't match\n" << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case ADD: {
        // primary goal of these checks is to forbid address arithmetic
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'add' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'add' yields exactly one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'add' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case SUBTRACT: {
        if (inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'subtract' has no ingredients\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (is_raw(inst.ingredients.at(i))) continue;  // permit address offset computations in tests
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'subtract' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'subtract' yields exactly one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'subtract' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case MULTIPLY: {
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'multiply' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'multiply' yields exactly one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'multiply' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case DIVIDE: {
        if (inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'divide' has no ingredients\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'divide' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'divide' yields exactly one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'divide' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case DIVIDE_WITH_REMAINDER: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 2) {
          raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' yields two products in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.products); ++i) {
          if (!is_dummy(inst.products.at(i)) && !is_mu_number(inst.products.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' should yield a number, but got " << inst.products.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case SHIFT_LEFT: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-left' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-left' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-left' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-left' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case SHIFT_RIGHT: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-right' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-right' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-right' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'shift-right' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case AND_BITS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'and-bits' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'and-bits' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'and-bits' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'and-bits' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case OR_BITS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'or-bits' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'or-bits' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'or-bits' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'or-bits' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case XOR_BITS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'xor-bits' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'xor-bits' requires number ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'xor-bits' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'xor-bits' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case FLIP_BITS: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'flip-bits' requires exactly one ingredient, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'flip-bits' requires a number ingredient, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (SIZE(inst.products) > 1) {
          raise_error << maybe(get(Recipe, r).name) << "'flip-bits' yields one product in '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'flip-bits' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end();
          goto finish_checking_instruction;
        }
        break;
      }
      case AND: {
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_scalar(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'and' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case OR: {
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_scalar(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'and' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case NOT: {
        if (SIZE(inst.products) > SIZE(inst.ingredients)) {
          raise_error << maybe(get(Recipe, r).name) << "'not' cannot have fewer ingredients than products in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_scalar(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'not' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case JUMP: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'jump' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'jump' should be a label or offset, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case JUMP_IF: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires exactly two ingredients, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires a label or offset for its second ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case JUMP_UNLESS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires exactly two ingredients, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires a label or offset for its second ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case EQUAL: {
        if (SIZE(inst.ingredients) <= 1) {
          raise_error << maybe(get(Recipe, r).name) << "'equal' needs at least two ingredients to compare in '" << to_string(inst) << "'\n" << end();
          break;
        }
        break;
      }
      case GREATER_THAN: {
        if (SIZE(inst.ingredients) <= 1) {
          raise_error << maybe(get(Recipe, r).name) << "'greater-than' needs at least two ingredients to compare in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'greater-than' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case LESSER_THAN: {
        if (SIZE(inst.ingredients) <= 1) {
          raise_error << maybe(get(Recipe, r).name) << "'lesser-than' needs at least two ingredients to compare in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'lesser-than' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case GREATER_OR_EQUAL: {
        if (SIZE(inst.ingredients) <= 1) {
          raise_error << maybe(get(Recipe, r).name) << "'greater-or-equal' needs at least two ingredients to compare in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'greater-or-equal' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case LESSER_OR_EQUAL: {
        if (SIZE(inst.ingredients) <= 1) {
          raise_error << maybe(get(Recipe, r).name) << "'lesser-or-equal' needs at least two ingredients to compare in '" << to_string(inst) << "'\n" << end();
          break;
        }
        for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
          if (!is_mu_number(inst.ingredients.at(i))) {
            raise_error << maybe(get(Recipe, r).name) << "'lesser-or-equal' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end();
            goto finish_checking_instruction;
          }
        }
        break;
      }
      case TRACE: {
        if (SIZE(inst.ingredients) < 3) {
          raise_error << maybe(get(Recipe, r).name) << "'trace' takes three or more ingredients rather than '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'trace' should be a number (depth), but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_literal_string(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'trace' should be a literal string (label), but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        break;
      }
      case STASH: {
        break;
      }
      case HIDE_ERRORS: {
        break;
      }
      case SHOW_ERRORS: {
        break;
      }
      case TRACE_UNTIL: {
        break;
      }
      case _DUMP_TRACE: {
        break;
      }
      case _CLEAR_TRACE: {
        break;
      }
      case _SAVE_TRACE: {
        break;
      }
      case ASSERT: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'assert' takes exactly two ingredients rather than '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_scalar(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'assert' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_literal_string(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "'assert' requires a literal string for its second ingredient, but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        break;
      }
      case _PRINT: {
        break;
      }
      case _EXIT: {
        break;
      }
      case _SYSTEM: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'$system' requires exactly one ingredient, but got none\n" << end();
          break;
        }
        break;
      }
      case _DUMP_MEMORY: {
        break;
      }
      case _LOG: {
        break;
      }
      case GET: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'get' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent base = inst.ingredients.at(0);  // new copy for every invocation
        // Update GET base in Check
        if (!canonize_type(base)) break;
        if (!base.type || !base.type->value || !contains_key(Type, base.type->value) || get(Type, base.type->value).kind != CONTAINER) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'get' should be a container, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        type_ordinal base_type = base.type->value;
        reagent offset = inst.ingredients.at(1);
        if (!is_literal(offset) || !is_mu_scalar(offset)) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'get' should have type 'offset', but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        long long int offset_value = 0;
        if (is_integer(offset.name))  // later layers permit non-integer offsets
          offset_value = to_integer(offset.name);
        else
          offset_value = offset.value;
        if (offset_value < 0 || offset_value >= SIZE(get(Type, base_type).elements)) {
          raise_error << maybe(get(Recipe, r).name) << "invalid offset " << offset_value << " for " << get(Type, base_type).name << '\n' << end();
          break;
        }
        if (inst.products.empty()) break;
        reagent product = inst.products.at(0);
        // Update GET product in Check
        if (!canonize_type(product)) break;
        const reagent element = element_type(base, offset_value);
        if (!types_coercible(product, element)) {
          raise_error << maybe(get(Recipe, r).name) << "'get " << base.original_string << ", " << offset.original_string << "' should write to " << names_to_string_without_quotes(element.type) << " but " << product.name << " has type " << names_to_string_without_quotes(product.type) << '\n' << end();
          break;
        }
        break;
      }
      case GET_ADDRESS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'get-address' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent base = inst.ingredients.at(0);
        // Update GET_ADDRESS base in Check
        if (!canonize_type(base)) break;
        if (!base.type || !base.type->value || !contains_key(Type, base.type->value) || get(Type, base.type->value).kind != CONTAINER) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'get-address' should be a container, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        type_ordinal base_type = base.type->value;
        reagent offset = inst.ingredients.at(1);
        if (!is_literal(offset) || !is_mu_scalar(offset)) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'get' should have type 'offset', but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        long long int offset_value = 0;
        if (is_integer(offset.name)) {  // later layers permit non-integer offsets
          offset_value = to_integer(offset.name);
          if (offset_value < 0 || offset_value >= SIZE(get(Type, base_type).elements)) {
            raise_error << maybe(get(Recipe, r).name) << "invalid offset " << offset_value << " for " << get(Type, base_type).name << '\n' << end();
            break;
          }
        }
        else {
          offset_value = offset.value;
        }
        reagent product = inst.products.at(0);
        // Update GET_ADDRESS product in Check
        if (!canonize_type(base)) break;
        // same type as for GET..
        reagent element = element_type(base, offset_value);
        // ..except for an address at the start
        element.type = new type_tree("address", get(Type_ordinal, "address"), element.type);
        if (!types_coercible(product, element)) {
          raise_error << maybe(get(Recipe, r).name) << "'get-address " << base.original_string << ", " << offset.original_string << "' should write to " << names_to_string_without_quotes(element.type) << " but " << product.name << " has type " << names_to_string_without_quotes(product.type) << '\n' << end();
          break;
        }
        break;
      }
      case MERGE: {
        // type-checking in a separate transform below
        break;
      }
      case CREATE_ARRAY: {
        if (inst.products.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'create-array' needs one product and no ingredients but got '" << to_string(inst) << '\n' << end();
          break;
        }
        reagent product = inst.products.at(0);
        canonize_type(product);
        if (!is_mu_array(product)) {
          raise_error << maybe(get(Recipe, r).name) << "'create-array' cannot create non-array " << product.original_string << '\n' << end();
          break;
        }
        if (!product.type->right) {
          raise_error << maybe(get(Recipe, r).name) << "create array of what? " << to_string(inst) << '\n' << end();
          break;
        }
        // 'create-array' will need to check properties rather than types
        if (!product.type->right->right) {
          raise_error << maybe(get(Recipe, r).name) << "create array of what size? " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_integer(product.type->right->right->name)) {
          raise_error << maybe(get(Recipe, r).name) << "'create-array' product should specify size of array after its element type, but got " << product.type->right->right->name << '\n' << end();
          break;
        }
        break;
      }
      case INDEX: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'index' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent base = inst.ingredients.at(0);
        canonize_type(base);
        if (!is_mu_array(base)) {
          raise_error << maybe(get(Recipe, r).name) << "'index' on a non-array " << base.original_string << '\n' << end();
          break;
        }
        if (inst.products.empty()) break;
        reagent product = inst.products.at(0);
        canonize_type(product);
        reagent element;
        element.type = new type_tree(*array_element(base.type));
        if (!types_coercible(product, element)) {
          raise_error << maybe(get(Recipe, r).name) << "'index' on " << base.original_string << " can't be saved in " << product.original_string << "; type should be " << names_to_string_without_quotes(element.type) << '\n' << end();
          break;
        }
        break;
      }
      case INDEX_ADDRESS: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'index-address' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent base = inst.ingredients.at(0);
        canonize_type(base);
        if (!is_mu_array(base)) {
          raise_error << maybe(get(Recipe, r).name) << "'index-address' on a non-array " << base.original_string << '\n' << end();
          break;
        }
        if (inst.products.empty()) break;
        reagent product = inst.products.at(0);
        canonize_type(product);
        reagent element;
        element.type = new type_tree("address", get(Type_ordinal, "address"),
                                     new type_tree(*array_element(base.type)));
        if (!types_coercible(product, element)) {
          raise_error << maybe(get(Recipe, r).name) << "'index' on " << base.original_string << " can't be saved in " << product.original_string << "; type should be " << names_to_string_without_quotes(element.type) << '\n' << end();
          break;
        }
        break;
      }
      case LENGTH: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'length' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent x = inst.ingredients.at(0);
        canonize_type(x);
        if (!is_mu_array(x)) {
          raise_error << "tried to calculate length of non-array " << x.original_string << '\n' << end();
          break;
        }
        break;
      }
      case MAYBE_CONVERT: {
        const recipe& caller = get(Recipe, r);
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(caller.name) << "'maybe-convert' expects exactly 2 ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent base = inst.ingredients.at(0);
        canonize_type(base);
        if (!base.type || !base.type->value || get(Type, base.type->value).kind != EXCLUSIVE_CONTAINER) {
          raise_error << maybe(caller.name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got " << base.original_string << '\n' << end();
          break;
        }
        if (!is_literal(inst.ingredients.at(1))) {
          raise_error << maybe(caller.name) << "second ingredient of 'maybe-convert' should have type 'variant', but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        if (inst.products.empty()) break;
        reagent product = inst.products.at(0);
        if (!canonize_type(product)) break;
        reagent& offset = inst.ingredients.at(1);
        populate_value(offset);
        if (offset.value >= SIZE(get(Type, base.type->value).elements)) {
          raise_error << maybe(caller.name) << "invalid tag " << offset.value << " in '" << to_string(inst) << '\n' << end();
          break;
        }
        reagent variant = variant_type(base, offset.value);
        variant.type = new type_tree("address", get(Type_ordinal, "address"), variant.type);
        if (!types_coercible(product, variant)) {
          raise_error << maybe(caller.name) << "'maybe-convert " << base.original_string << ", " << inst.ingredients.at(1).original_string << "' should write to " << to_string(variant.type) << " but " << product.name << " has type " << to_string(product.type) << '\n' << end();
          break;
        }
        break;
      }
      case NEXT_INGREDIENT: {
        if (!inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'next-ingredient' didn't expect any ingredients in '" << to_string(inst) << "'\n" << end();
          break;
        }
        break;
      }
      case REWIND_INGREDIENTS: {
        break;
      }
      case INGREDIENT: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'ingredient' expects exactly one ingredient, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_literal(inst.ingredients.at(0)) && !is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'ingredient' expects a literal ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case REPLY: {
        break;  // checks will be performed by a transform below
      }
      case NEW: {
        const recipe& caller = get(Recipe, r);
        if (inst.ingredients.empty() || SIZE(inst.ingredients) > 2) {
          raise_error << maybe(caller.name) << "'new' requires one or two ingredients, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (is_literal_string(inst.ingredients.at(0))) break;
        // End NEW Check Special-cases
        reagent type = inst.ingredients.at(0);
        if (!is_mu_type_literal(type)) {
          raise_error << maybe(caller.name) << "first ingredient of 'new' should be a type, but got " << type.original_string << '\n' << end();
          break;
        }
        if (inst.products.empty()) {
          raise_error << maybe(caller.name) << "result of 'new' should never be ignored\n" << end();
          break;
        }
        if (!product_of_new_is_valid(inst)) {
          raise_error << maybe(caller.name) << "product of 'new' has incorrect type: " << to_string(inst) << '\n' << end();
          break;
        }
        break;
      }
      case ALLOCATE: {
        raise << "never call 'allocate' directly'; always use 'new'\n" << end();
        break;
      }

      case ABANDON: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'abandon' requires one ingredient, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        reagent types = inst.ingredients.at(0);
        canonize_type(types);
        if (!types.type || types.type->value != get(Type_ordinal, "address") || types.type->right->value != get(Type_ordinal, "shared")) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'abandon' should be an address:shared:___, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case TO_LOCATION_ARRAY: {
        const recipe& caller = get(Recipe, r);
        if (!is_shared_address_of_array_of_numbers(inst.products.at(0))) {
          raise_error << maybe(caller.name) << "product of 'to-location-array' has incorrect type: " << to_string(inst) << '\n' << end();
          break;
        }
        break;
      }
      case BREAK: break;
      case BREAK_IF: break;
      case BREAK_UNLESS: break;
      case LOOP: break;
      case LOOP_IF: break;
      case LOOP_UNLESS: break;

      case RUN: {
        break;
      }
      case MEMORY_SHOULD_CONTAIN: {
        break;
      }
      case TRACE_SHOULD_CONTAIN: {
        break;
      }
      case TRACE_SHOULD_NOT_CONTAIN: {
        break;
      }
      case CHECK_TRACE_COUNT_FOR_LABEL: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'check-trace-for-label' requires exactly two ingredients, but got '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'check-trace-for-label' should be a number (count), but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_literal_string(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'check-trace-for-label' should be a literal string (label), but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        break;
      }
      case NEXT_INGREDIENT_WITHOUT_TYPECHECKING: {
        break;
      }
      case CALL: {
        if (inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'call' requires at least one ingredient (the recipe to call)\n" << end();
          break;
        }
        if (!is_mu_recipe(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'call' should be a recipe, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case START_RUNNING: {
        if (inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'start-running' requires at least one ingredient: the recipe to start running\n" << end();
          break;
        }
        if (!is_mu_recipe(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'start-running' should be a recipe, but got " << to_string(inst.ingredients.at(0)) << '\n' << end();
          break;
        }
        break;
      }
      case ROUTINE_STATE: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'routine-state' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'routine-state' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case RESTART: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'restart' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'restart' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case STOP: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'stop' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'stop' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case _DUMP_ROUTINES: {
        break;
      }
      case LIMIT_TIME: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'limit-time' requires exactly two ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'limit-time' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'limit-time' should be a number (of instructions to run for), but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        break;
      }
      case WAIT_FOR_LOCATION: {
        break;
      }
      case WAIT_FOR_ROUTINE: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'wait-for-routine' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'wait-for-routine' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case SWITCH: {
        break;
      }
      case RANDOM: {
        break;
      }
      case MAKE_RANDOM_NONDETERMINISTIC: {
        break;
      }
      case ROUND: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'round' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'round' should be a number, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case HASH: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'hash' takes exactly one ingredient rather than '" << to_string(inst) << "'\n" << end();
          break;
        }
        break;
      }
      case HASH_OLD: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'hash_old' takes exactly one ingredient rather than '" << to_string(inst) << "'\n" << end();
          break;
        }
        if (!is_mu_string(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "'hash_old' currently only supports strings (address:shared:array:character), but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case OPEN_CONSOLE: {
        break;
      }
      case CLOSE_CONSOLE: {
        break;
      }
      case CLEAR_DISPLAY: {
        break;
      }
      case SYNC_DISPLAY: {
        break;
      }
      case CLEAR_LINE_ON_DISPLAY: {
        break;
      }
      case PRINT_CHARACTER_TO_DISPLAY: {
        if (inst.ingredients.empty()) {
          raise_error << maybe(get(Recipe, r).name) << "'print-character-to-display' requires at least one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'print-character-to-display' should be a character, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (SIZE(inst.ingredients) > 1) {
          if (!is_mu_number(inst.ingredients.at(1))) {
            raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'print-character-to-display' should be a foreground color number, but got " << inst.ingredients.at(1).original_string << '\n' << end();
            break;
          }
        }
        if (SIZE(inst.ingredients) > 2) {
          if (!is_mu_number(inst.ingredients.at(2))) {
            raise_error << maybe(get(Recipe, r).name) << "third ingredient of 'print-character-to-display' should be a background color number, but got " << inst.ingredients.at(2).original_string << '\n' << end();
            break;
          }
        }
        break;
      }
      case CURSOR_POSITION_ON_DISPLAY: {
        break;
      }
      case MOVE_CURSOR_ON_DISPLAY: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'move-cursor-on-display' requires two ingredients, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'move-cursor-on-display' should be a row number, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        if (!is_mu_number(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'move-cursor-on-display' should be a column number, but got " << inst.ingredients.at(1).original_string << '\n' << end();
          break;
        }
        break;
      }
      case MOVE_CURSOR_DOWN_ON_DISPLAY: {
        break;
      }
      case MOVE_CURSOR_UP_ON_DISPLAY: {
        break;
      }
      case MOVE_CURSOR_RIGHT_ON_DISPLAY: {
        break;
      }
      case MOVE_CURSOR_LEFT_ON_DISPLAY: {
        break;
      }
      case DISPLAY_WIDTH: {
        break;
      }
      case DISPLAY_HEIGHT: {
        break;
      }
      case HIDE_CURSOR_ON_DISPLAY: {
        break;
      }
      case SHOW_CURSOR_ON_DISPLAY: {
        break;
      }
      case HIDE_DISPLAY: {
        break;
      }
      case SHOW_DISPLAY: {
        break;
      }
      case WAIT_FOR_SOME_INTERACTION: {
        break;
      }
      case CHECK_FOR_INTERACTION: {
        break;
      }
      case INTERACTIONS_LEFT: {
        break;
      }
      case CLEAR_DISPLAY_FROM: {
        break;
      }
      case SCREEN_SHOULD_CONTAIN: {
        break;
      }
      case SCREEN_SHOULD_CONTAIN_IN_COLOR: {
        break;
      }
      case _DUMP_SCREEN: {
        break;
      }
      case ASSUME_CONSOLE: {
        break;
      }
      case REPLACE_IN_CONSOLE: {
        break;
      }
      case _BROWSE_TRACE: {
        break;
      }
      case RUN_INTERACTIVE: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'run-interactive' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_string(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'run-interactive' should be a string, but got " << to_string(inst.ingredients.at(0)) << '\n' << end();
          break;
        }
        break;
      }
      case _START_TRACKING_PRODUCTS: {
        break;
      }
      case _STOP_TRACKING_PRODUCTS: {
        break;
      }
      case _MOST_RECENT_PRODUCTS: {
        break;
      }
      case SAVE_ERRORS_WARNINGS: {
        break;
      }
      case SAVE_APP_TRACE: {
        break;
      }
      case _CLEANUP_RUN_INTERACTIVE: {
        break;
      }
      case RELOAD: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'reload' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (!is_mu_string(inst.ingredients.at(0))) {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'reload' should be a string, but got " << inst.ingredients.at(0).original_string << '\n' << end();
          break;
        }
        break;
      }
      case RESTORE: {
        if (SIZE(inst.ingredients) != 1) {
          raise_error << maybe(get(Recipe, r).name) << "'restore' requires exactly one ingredient, but got " << to_string(inst) << '\n' << end();
          break;
        }
        string filename;
        if (is_literal_string(inst.ingredients.at(0))) {
          ;
        }
        else if (is_mu_string(inst.ingredients.at(0))) {
          ;
        }
        else {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'restore' should be a string, but got " << to_string(inst.ingredients.at(0)) << '\n' << end();
          break;
        }
        break;
      }
      case SAVE: {
        if (SIZE(inst.ingredients) != 2) {
          raise_error << maybe(get(Recipe, r).name) << "'save' requires exactly two ingredients, but got " << to_string(inst) << '\n' << end();
          break;
        }
        if (is_literal_string(inst.ingredients.at(0))) {
          ;
        }
        else if (is_mu_string(inst.ingredients.at(0))) {
          ;
        }
        else {
          raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'save' should be a string, but got " << to_string(inst.ingredients.at(0)) << '\n' << end();
          break;
        }
        if (!is_mu_string(inst.ingredients.at(1))) {
          raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'save' should be an address:array:character, but got " << to_string(inst.ingredients.at(1)) << '\n' << end();
          break;
        }
        break;
      }
      // End Primitive Recipe Checks
      default: {
        // Defined Recipe Checks
        // not a primitive; check that it's present in the book of recipes
        if (!contains_key(Recipe, inst.operation)) {
          raise_error << maybe(get(Recipe, r).name) << "undefined operation in '" << to_string(inst) << "'\n" << end();
          break;
        }
        // End Defined Recipe Checks
      }
    }
    finish_checking_instruction:;
  }
}

void test_copy_checks_reagent_count() {
  Trace_file = "copy_checks_reagent_count";
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy 34, 35\n]\n");
  CHECK_TRACE_CONTENTS("error: ingredients and products should match in '1:number <- copy 34, 35'");
}
void test_write_scalar_to_array_disallowed() {
  Trace_file = "write_scalar_to_array_disallowed";
  Hide_errors = true;
  run("recipe main [\n  1:array:number <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy 34 to 1:array:number; types don't match");
}
void test_write_scalar_to_array_disallowed_2() {
  Trace_file = "write_scalar_to_array_disallowed_2";
  Hide_errors = true;
  run("recipe main [\n  1:number, 2:array:number <- copy 34, 35\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy 35 to 2:array:number; types don't match");
}
void test_write_scalar_to_address_disallowed() {
  Trace_file = "write_scalar_to_address_disallowed";
  Hide_errors = true;
  run("recipe main [\n  1:address:number <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy 34 to 1:address:number; types don't match");
}
void test_write_address_to_number_allowed() {
  Trace_file = "write_address_to_number_allowed";
  Hide_errors = true;
  run("recipe main [\n  1:address:number <- copy 12/unsafe\n  2:number <- copy 1:address:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 2");
  CHECK_TRACE_COUNT("error", 0);
}
void test_write_boolean_to_number_allowed() {
  Trace_file = "write_boolean_to_number_allowed";
  Hide_errors = true;
  run("recipe main [\n  1:boolean <- copy 1/true\n  2:number <- copy 1:boolean\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 2");
  CHECK_TRACE_COUNT("error", 0);
}
// types_match with some leniency
bool types_coercible(const reagent& to, const reagent& from) {
  if (types_match(to, from)) return true;
  if (is_mu_address(from) && is_mu_number(to)) return true;
  if (is_mu_boolean(from) && is_mu_number(to)) return true;
  // End types_coercible Special-cases
  return false;
}

bool types_match(const reagent& to, const reagent& from) {
  // to sidestep type-checking, use /unsafe in the source.
  // this will be highlighted in red inside vim. just for setting up some tests.
  if (is_unsafe(from)) return true;
  if (is_literal(from)) {
    if (is_mu_array(to)) return false;
    if (contains_type_ingredient_name(to)) return false;

    if (is_mu_recipe(to)) {
      if (!contains_key(Recipe, from.value)) {
        raise_error << "trying to store recipe " << from.name << " into " << to_string(to) << " but there's no such recipe\n" << end();
        return false;
      }
      const recipe& rrhs = get(Recipe, from.value);
      const recipe& rlhs = from_reagent(to);
      for (long int i = 0; i < min(SIZE(rlhs.ingredients), SIZE(rrhs.ingredients)); ++i) {
        if (!types_match(rlhs.ingredients.at(i), rrhs.ingredients.at(i)))
          return false;
      }
      for (long int i = 0; i < min(SIZE(rlhs.products), SIZE(rrhs.products)); ++i) {
        if (!types_match(rlhs.products.at(i), rrhs.products.at(i)))
          return false;
      }
      return true;
    }

    // End Matching Types For Literal(to)
    // allow writing 0 to any address
    if (is_mu_address(to)) return from.name == "0";
    if (!to.type) return false;
    if (to.type->value == get(Type_ordinal, "boolean"))
      return boolean_matches_literal(to, from);
    return size_of(to) == 1;  // literals are always scalars
  }
  return types_strictly_match(to, from);
}

bool types_strictly_match_except_literal_against_boolean(const reagent& to, const reagent& from) {
  // to sidestep type-checking, use /unsafe in the source.
  // this will be highlighted in red inside vim. just for setting up some tests.
  if (is_literal(from)
      && to.type && to.type->value == get(Type_ordinal, "boolean"))
    return boolean_matches_literal(to, from);
  return types_strictly_match(to, from);
}

bool boolean_matches_literal(const reagent& to, const reagent& from) {
  if (!is_literal(from)) return false;
  if (!to.type) return false;
  if (to.type->value != get(Type_ordinal, "boolean")) return false;
  return from.name == "0" || from.name == "1";
}

// copy arguments because later layers will want to make changes to them
// without perturbing the caller
bool types_strictly_match(reagent to, reagent from) {
  if (!canonize_type(to)) return false;
  if (!canonize_type(from)) return false;

  if (is_literal(from) && to.type->value == get(Type_ordinal, "number")) return true;
  // to sidestep type-checking, use /unsafe in the source.
  // this will be highlighted in red inside vim. just for setting up some tests.
  if (is_unsafe(from)) return true;
  // '_' never raises type error
  if (is_dummy(to)) return true;
  if (!to.type) return !from.type;
  return types_strictly_match(to.type, from.type);
}

// two types match if the second begins like the first
// (trees perform the same check recursively on each subtree)
bool types_strictly_match(type_tree* to, type_tree* from) {
  if (!to) return true;
  if (!from) return to->value == 0;
  if (to->value != from->value) return false;
  return types_strictly_match(to->left, from->left) && types_strictly_match(to->right, from->right);
}

bool is_unsafe(const reagent& r) {
  return has_property(r, "unsafe");
}

bool is_mu_array(reagent r) {
  if (!canonize_type(r)) return false;

  if (!r.type) return false;
  if (is_literal(r)) return false;
  return r.type->value == get(Type_ordinal, "array");
}

bool is_mu_address(reagent r) {
  if (!canonize_type(r)) return false;

  if (!r.type) return false;
  if (is_literal(r)) return false;
  return r.type->value == get(Type_ordinal, "address");
}

bool is_mu_boolean(reagent r) {
  if (!r.type) return false;
  if (is_literal(r)) return false;
  return r.type->value == get(Type_ordinal, "boolean");
}

bool is_mu_number(reagent r) {
  if (!canonize_type(r)) return false;

  if (!r.type) return false;
  if (is_literal(r)) {
    if (!r.type) return false;
    return r.type->name == "literal-fractional-number"
        || r.type->name == "literal";
  }
  if (r.type->value == get(Type_ordinal, "character")) return true;  // permit arithmetic on unicode code points
  return r.type->value == get(Type_ordinal, "number");
}

bool is_mu_scalar(reagent r) {
  if (!r.type) return false;
  if (is_literal(r))
    return !r.type || r.type->name != "literal-string";
  if (is_mu_array(r)) return false;
  return size_of(r) == 1;
}


void test_add_literal() {
  Trace_file = "add_literal";
  run("recipe main [\n  1:number <- add 23, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 57 in location 1");
}
void test_add() {
  Trace_file = "add";
  run("recipe main [\n  1:number <- copy 23\n  2:number <- copy 34\n  3:number <- add 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 57 in location 3");
}
void test_add_multiple() {
  Trace_file = "add_multiple";
  run("recipe main [\n  1:number <- add 3, 4, 5\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 1");
}
void test_add_checks_type() {
  Trace_file = "add_checks_type";
  Hide_errors = true;
  run("recipe main [\n  1:number <- add 2:boolean, 1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'add' requires number ingredients, but got 2:boolean");
}
void test_add_checks_return_type() {
  Trace_file = "add_checks_return_type";
  Hide_errors = true;
  run("recipe main [\n  1:address:number <- add 2, 2\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'add' should yield a number, but got 1:address:number");
}
bool is_raw(const reagent& r) {
  return has_property(r, "raw");
}

void test_subtract_literal() {
  Trace_file = "subtract_literal";
  run("recipe main [\n  1:number <- subtract 5, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 1");
}
void test_subtract() {
  Trace_file = "subtract";
  run("recipe main [\n  1:number <- copy 23\n  2:number <- copy 34\n  3:number <- subtract 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing -11 in location 3");
}
void test_subtract_multiple() {
  Trace_file = "subtract_multiple";
  run("recipe main [\n  1:number <- subtract 6, 3, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_multiply_literal() {
  Trace_file = "multiply_literal";
  run("recipe main [\n  1:number <- multiply 2, 3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 6 in location 1");
}
void test_multiply() {
  Trace_file = "multiply";
  run("recipe main [\n  1:number <- copy 4\n  2:number <- copy 6\n  3:number <- multiply 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 24 in location 3");
}
void test_multiply_multiple() {
  Trace_file = "multiply_multiple";
  run("recipe main [\n  1:number <- multiply 2, 3, 4\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 24 in location 1");
}
void test_divide_literal() {
  Trace_file = "divide_literal";
  run("recipe main [\n  1:number <- divide 8, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_divide() {
  Trace_file = "divide";
  run("recipe main [\n  1:number <- copy 27\n  2:number <- copy 3\n  3:number <- divide 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 9 in location 3");
}
void test_divide_multiple() {
  Trace_file = "divide_multiple";
  run("recipe main [\n  1:number <- divide 12, 3, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_divide_with_remainder_literal() {
  Trace_file = "divide_with_remainder_literal";
  run("recipe main [\n  1:number, 2:number <- divide-with-remainder 9, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1mem: storing 1 in location 2");
}
void test_divide_with_remainder() {
  Trace_file = "divide_with_remainder";
  run("recipe main [\n  1:number <- copy 27\n  2:number <- copy 11\n  3:number, 4:number <- divide-with-remainder 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 3mem: storing 5 in location 4");
}
void test_divide_with_decimal_point() {
  Trace_file = "divide_with_decimal_point";
  run("recipe main [\n  1:number <- divide 5, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2.5 in location 1");
}
void test_divide_by_zero() {
  Trace_file = "divide_by_zero";
  run("recipe main [\n  1:number <- divide 4, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing inf in location 1");
}
void test_divide_by_zero_2() {
  Trace_file = "divide_by_zero_2";
  Hide_errors = true;
  run("recipe main [\n  1:number <- divide-with-remainder 4, 0\n]\n# integer division can't return floating-point infinity\n");
  CHECK_TRACE_CONTENTS("error: main: divide by zero in '1:number <- divide-with-remainder 4, 0'");
}
void test_shift_left_by_zero() {
  Trace_file = "shift_left_by_zero";
  run("recipe main [\n  1:number <- shift-left 1, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_shift_left_1() {
  Trace_file = "shift_left_1";
  run("recipe main [\n  1:number <- shift-left 1, 4\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 16 in location 1");
}
void test_shift_left_2() {
  Trace_file = "shift_left_2";
  run("recipe main [\n  1:number <- shift-left 3, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 1");
}
void test_shift_left_by_negative() {
  Trace_file = "shift_left_by_negative";
  Hide_errors = true;
  run("recipe main [\n  1:number <- shift-left 3, -1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: second ingredient can't be negative in '1:number <- shift-left 3, -1'");
}
void test_shift_left_ignores_fractional_part() {
  Trace_file = "shift_left_ignores_fractional_part";
  run("recipe main [\n  1:number <- divide 3, 2\n  2:number <- shift-left 1:number, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 2");
}
void test_shift_right_by_zero() {
  Trace_file = "shift_right_by_zero";
  run("recipe main [\n  1:number <- shift-right 1, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_shift_right_1() {
  Trace_file = "shift_right_1";
  run("recipe main [\n  1:number <- shift-right 1024, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 512 in location 1");
}
void test_shift_right_2() {
  Trace_file = "shift_right_2";
  run("recipe main [\n  1:number <- shift-right 3, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_shift_right_by_negative() {
  Trace_file = "shift_right_by_negative";
  Hide_errors = true;
  run("recipe main [\n  1:number <- shift-right 4, -1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: second ingredient can't be negative in '1:number <- shift-right 4, -1'");
}
void test_shift_right_ignores_fractional_part() {
  Trace_file = "shift_right_ignores_fractional_part";
  run("recipe main [\n  1:number <- divide 3, 2\n  2:number <- shift-right 1:number, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2");
}
void test_and_bits_1() {
  Trace_file = "and_bits_1";
  run("recipe main [\n  1:number <- and-bits 8, 3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_and_bits_2() {
  Trace_file = "and_bits_2";
  run("recipe main [\n  1:number <- and-bits 3, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_and_bits_3() {
  Trace_file = "and_bits_3";
  run("recipe main [\n  1:number <- and-bits 14, 3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_and_bits_negative() {
  Trace_file = "and_bits_negative";
  run("recipe main [\n  1:number <- and-bits -3, 4\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_or_bits_1() {
  Trace_file = "or_bits_1";
  run("recipe main [\n  1:number <- or-bits 3, 8\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 11 in location 1");
}
void test_or_bits_2() {
  Trace_file = "or_bits_2";
  run("recipe main [\n  1:number <- or-bits 3, 10\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 11 in location 1");
}
void test_or_bits_3() {
  Trace_file = "or_bits_3";
  run("recipe main [\n  1:number <- or-bits 4, 6\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 6 in location 1");
}
void test_xor_bits_1() {
  Trace_file = "xor_bits_1";
  run("recipe main [\n  1:number <- xor-bits 3, 8\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 11 in location 1");
}
void test_xor_bits_2() {
  Trace_file = "xor_bits_2";
  run("recipe main [\n  1:number <- xor-bits 3, 10\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 9 in location 1");
}
void test_xor_bits_3() {
  Trace_file = "xor_bits_3";
  run("recipe main [\n  1:number <- xor-bits 4, 6\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_flip_bits_zero() {
  Trace_file = "flip_bits_zero";
  run("recipe main [\n  1:number <- flip-bits 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing -1 in location 1");
}
void test_flip_bits_negative() {
  Trace_file = "flip_bits_negative";
  run("recipe main [\n  1:number <- flip-bits -1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_flip_bits_1() {
  Trace_file = "flip_bits_1";
  run("recipe main [\n  1:number <- flip-bits 3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing -4 in location 1");
}
void test_flip_bits_2() {
  Trace_file = "flip_bits_2";
  run("recipe main [\n  1:number <- flip-bits 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing -13 in location 1");
}

void test_and() {
  Trace_file = "and";
  run("recipe main [\n  1:boolean <- copy 1\n  2:boolean <- copy 0\n  3:boolean <- and 1:boolean, 2:boolean\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_and_2() {
  Trace_file = "and_2";
  run("recipe main [\n  1:boolean <- and 1, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_and_multiple() {
  Trace_file = "and_multiple";
  run("recipe main [\n  1:boolean <- and 1, 1, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_and_multiple_2() {
  Trace_file = "and_multiple_2";
  run("recipe main [\n  1:boolean <- and 1, 1, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_or() {
  Trace_file = "or";
  run("recipe main [\n  1:boolean <- copy 1\n  2:boolean <- copy 0\n  3:boolean <- or 1:boolean, 2:boolean\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_or_2() {
  Trace_file = "or_2";
  run("recipe main [\n  1:boolean <- or 0, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_or_multiple() {
  Trace_file = "or_multiple";
  run("recipe main [\n  1:boolean <- and 0, 0, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_or_multiple_2() {
  Trace_file = "or_multiple_2";
  run("recipe main [\n  1:boolean <- or 0, 0, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_not() {
  Trace_file = "not";
  run("recipe main [\n  1:boolean <- copy 1\n  2:boolean <- not 1:boolean\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2");
}
void test_not_multiple() {
  Trace_file = "not_multiple";
  run("recipe main [\n  1:boolean, 2:boolean, 3:boolean <- not 1, 0, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 1 in location 2mem: storing 0 in location 3");
}

void test_jump_can_skip_instructions() {
  Trace_file = "jump_can_skip_instructions";
  run("recipe main [\n  jump 1:offset\n  1:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("run: jump 1:offset");
  CHECK_TRACE_DOESNT_CONTAIN("run: 1:number <- copy 1");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 1 in location 1");
}
void test_jump_backward() {
  Trace_file = "jump_backward";
  run("recipe main [\n  jump 1:offset  # 0 -+\n  jump 3:offset  #    |   +-+ 1\n                 #   \\/  /\\ |\n  jump -2:offset #  2 +-->+ |\n]                #         \\/ 3\n");
  CHECK_TRACE_CONTENTS("run: jump 1:offsetrun: jump -2:offsetrun: jump 3:offset");
}
void test_jump_if() {
  Trace_file = "jump_if";
  run("recipe main [\n  jump-if 999, 1:offset\n  123:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("run: jump-if 999, 1:offsetrun: jumping to instruction 2");
  CHECK_TRACE_DOESNT_CONTAIN("run: 1:number <- copy 1");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 1 in location 123");
}
void test_jump_if_fallthrough() {
  Trace_file = "jump_if_fallthrough";
  run("recipe main [\n  jump-if 0, 1:offset\n  123:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("run: jump-if 0, 1:offsetrun: jump-if fell throughrun: 123:number <- copy 1mem: storing 1 in location 123");
}
void test_jump_unless() {
  Trace_file = "jump_unless";
  run("recipe main [\n  jump-unless 0, 1:offset\n  123:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("run: jump-unless 0, 1:offsetrun: jumping to instruction 2");
  CHECK_TRACE_DOESNT_CONTAIN("run: 123:number <- copy 1");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 1 in location 123");
}
void test_jump_unless_fallthrough() {
  Trace_file = "jump_unless_fallthrough";
  run("recipe main [\n  jump-unless 999, 1:offset\n  123:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("run: jump-unless 999, 1:offsetrun: jump-unless fell throughrun: 123:number <- copy 1mem: storing 1 in location 123");
}

void test_equal() {
  Trace_file = "equal";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 33\n  3:number <- equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: location 1 is 34mem: location 2 is 33mem: storing 0 in location 3");
}
void test_equal_2() {
  Trace_file = "equal_2";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 34\n  3:number <- equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: location 1 is 34mem: location 2 is 34mem: storing 1 in location 3");
}
void test_equal_multiple() {
  Trace_file = "equal_multiple";
  run("recipe main [\n  1:number <- equal 34, 34, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_equal_multiple_2() {
  Trace_file = "equal_multiple_2";
  run("recipe main [\n  1:number <- equal 34, 34, 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_greater_than() {
  Trace_file = "greater_than";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 33\n  3:boolean <- greater-than 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_greater_than_2() {
  Trace_file = "greater_than_2";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 34\n  3:boolean <- greater-than 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_greater_than_multiple() {
  Trace_file = "greater_than_multiple";
  run("recipe main [\n  1:boolean <- greater-than 36, 35, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_greater_than_multiple_2() {
  Trace_file = "greater_than_multiple_2";
  run("recipe main [\n  1:boolean <- greater-than 36, 35, 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_lesser_than() {
  Trace_file = "lesser_than";
  run("recipe main [\n  1:number <- copy 32\n  2:number <- copy 33\n  3:boolean <- lesser-than 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_lesser_than_2() {
  Trace_file = "lesser_than_2";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 33\n  3:boolean <- lesser-than 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_lesser_than_multiple() {
  Trace_file = "lesser_than_multiple";
  run("recipe main [\n  1:boolean <- lesser-than 34, 35, 36\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_lesser_than_multiple_2() {
  Trace_file = "lesser_than_multiple_2";
  run("recipe main [\n  1:boolean <- lesser-than 34, 35, 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_greater_or_equal() {
  Trace_file = "greater_or_equal";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 33\n  3:boolean <- greater-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_greater_or_equal_2() {
  Trace_file = "greater_or_equal_2";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 34\n  3:boolean <- greater-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_greater_or_equal_3() {
  Trace_file = "greater_or_equal_3";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 35\n  3:boolean <- greater-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_greater_or_equal_multiple() {
  Trace_file = "greater_or_equal_multiple";
  run("recipe main [\n  1:boolean <- greater-or-equal 36, 35, 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_greater_or_equal_multiple_2() {
  Trace_file = "greater_or_equal_multiple_2";
  run("recipe main [\n  1:boolean <- greater-or-equal 36, 35, 36\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}
void test_lesser_or_equal() {
  Trace_file = "lesser_or_equal";
  run("recipe main [\n  1:number <- copy 32\n  2:number <- copy 33\n  3:boolean <- lesser-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_lesser_or_equal_2() {
  Trace_file = "lesser_or_equal_2";
  run("recipe main [\n  1:number <- copy 33\n  2:number <- copy 33\n  3:boolean <- lesser-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_lesser_or_equal_3() {
  Trace_file = "lesser_or_equal_3";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 33\n  3:boolean <- lesser-or-equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_lesser_or_equal_multiple() {
  Trace_file = "lesser_or_equal_multiple";
  run("recipe main [\n  1:boolean <- lesser-or-equal 34, 35, 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1");
}
void test_lesser_or_equal_multiple_2() {
  Trace_file = "lesser_or_equal_multiple_2";
  run("recipe main [\n  1:boolean <- lesser-or-equal 34, 35, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
}

void test_trace() {
  Trace_file = "trace";
  run("recipe main [\n  trace 1, [foo], [this is a trace in mu]\n]\n");
  CHECK_TRACE_CONTENTS("foo: this is a trace in mu");
}
void test_stash_literal_string() {
  Trace_file = "stash_literal_string";
  run("recipe main [\n  stash [foo]\n]\n");
  CHECK_TRACE_CONTENTS("app: foo");
}
void test_stash_literal_number() {
  Trace_file = "stash_literal_number";
  run("recipe main [\n  stash [foo:], 4\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: 4");
}
void test_stash_number() {
  Trace_file = "stash_number";
  run("recipe main [\n  1:number <- copy 34\n  stash [foo:], 1:number\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: 34");
}
string print_mu(const reagent& r, const vector<double>& data) {
  if (is_literal(r))
    return r.name+' ';
  if (is_mu_string(r)) {
    assert(scalar(data));
    return read_mu_string(data.at(0))+' ';
  }

  // End print Special-cases(reagent r, data)
  ostringstream out;
  for (long long i = 0; i < SIZE(data); ++i)
    out << no_scientific(data.at(i)) << ' ';
  return out.str();
}

void test_assert() {
  Trace_file = "assert";
  Hide_errors = true;  // '%' lines insert arbitrary C code into tests before calling 'run' with the lines below. Must be immediately after :(scenario) line.
  run("recipe main [\n  assert 0, [this is an assert in mu]\n]\n");
  CHECK_TRACE_CONTENTS("error: this is an assert in mu");
}

void test_copy_multiple_locations() {
  Trace_file = "copy_multiple_locations";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 35\n  3:point <- copy 1:point/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 3mem: storing 35 in location 4");
}
void test_copy_checks_size() {
  Trace_file = "copy_checks_size";
  Hide_errors = true;
  run("recipe main [\n  2:point <- copy 1:number\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy 1:number to 2:point; types don't match");
}
void test_copy_handles_nested_container_elements() {
  Trace_file = "copy_handles_nested_container_elements";
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  15:point-number <- copy 12:point-number/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 36 in location 17");
}
void test_compare_multiple_locations() {
  Trace_file = "compare_multiple_locations";
  run("recipe main [\n  1:number <- copy 34  # first\n  2:number <- copy 35\n  3:number <- copy 36\n  4:number <- copy 34  # second\n  5:number <- copy 35\n  6:number <- copy 36\n  7:boolean <- equal 1:point-number/raw, 4:point-number/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 7");
}
void test_compare_multiple_locations_2() {
  Trace_file = "compare_multiple_locations_2";
  run("recipe main [\n  1:number <- copy 34  # first\n  2:number <- copy 35\n  3:number <- copy 36\n  4:number <- copy 34  # second\n  5:number <- copy 35\n  6:number <- copy 37  # different\n  7:boolean <- equal 1:point-number/raw, 4:point-number/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 7");
}
void test_stash_container() {
  Trace_file = "stash_container";
  run("recipe main [\n  1:number <- copy 34  # first\n  2:number <- copy 35\n  3:number <- copy 36\n  stash [foo:], 1:point-number/raw\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: 34 35 36");
}
void test_get() {
  Trace_file = "get";
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  15:number <- get 12:point/raw, 1:offset  # unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 15");
}
const reagent element_type(const reagent& canonized_base, long long int offset_value) {
  assert(offset_value >= 0);
  assert(contains_key(Type, canonized_base.type->value));
  assert(!get(Type, canonized_base.type->value).name.empty());
  const type_info& info = get(Type, canonized_base.type->value);
  assert(info.kind == CONTAINER);
  reagent element = info.elements.at(offset_value);
  if (contains_type_ingredient(element)) {
    if (!canonized_base.type->right)
      raise_error << "illegal type " << names_to_string(canonized_base.type) << " seems to be missing a type ingredient or three\n" << end();
    replace_type_ingredients(element.type, canonized_base.type->right, info);
  }

  // End element_type Special-cases
  return element;
}

void test_get_handles_nested_container_elements() {
  Trace_file = "get_handles_nested_container_elements";
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  15:number <- get 12:point-number/raw, 1:offset  # unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 36 in location 15");
}
void test_get_out_of_bounds() {
  Trace_file = "get_out_of_bounds";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  get 12:point-number/raw, 2:offset  # point-number occupies 3 locations but has only 2 fields; out of bounds\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid offset 2 for point-number");
}
void test_get_out_of_bounds_2() {
  Trace_file = "get_out_of_bounds_2";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  get 12:point-number/raw, -1:offset\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid offset -1 for point-number");
}
void test_get_product_type_mismatch() {
  Trace_file = "get_product_type_mismatch";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  15:address:number <- get 12:point-number/raw, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'get 12:point-number/raw, 1:offset' should write to number but 15 has type (address number)");
}
void test_get_without_product() {
  Trace_file = "get_without_product";
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  get 12:point/raw, 1:offset  # unsafe\n]\n# just don't die\n");
}
void test_get_address() {
  Trace_file = "get_address";
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  15:address:number <- get-address 12:point/raw, 1:offset  # unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 13 in location 15");
}
void test_get_address_out_of_bounds() {
  Trace_file = "get_address_out_of_bounds";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  get-address 12:point-number/raw, 2:offset  # point-number occupies 3 locations but has only 2 fields; out of bounds\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid offset 2 for point-number");
}
void test_get_address_out_of_bounds_2() {
  Trace_file = "get_address_out_of_bounds_2";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 34\n  13:number <- copy 35\n  14:number <- copy 36\n  get-address 12:point-number/raw, -1:offset\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid offset -1 for point-number");
}
void test_get_address_product_type_mismatch() {
  Trace_file = "get_address_product_type_mismatch";
  Hide_errors = true;
  run("container boolbool [\n  x:boolean\n  y:boolean\n]\nrecipe main [\n  12:boolean <- copy 1\n  13:boolean <- copy 0\n  15:boolean <- get-address 12:boolbool, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'get-address 12:boolbool, 1:offset' should write to (address boolean) but 15 has type boolean");
}
void test_container() {
  Trace_file = "container";
  load("container foo [\n  x:number\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: --- defining container fooparse: element: x: \"number\"parse: element: y: \"number\"");
}
void test_container_use_before_definition() {
  Trace_file = "container_use_before_definition";
  load("container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  x:number\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: --- defining container fooparse: type number: 1000parse:   element: x: \"number\"parse:   element: y: \"bar\"parse: --- defining container barparse: type number: 1001parse:   element: x: \"number\"parse:   element: y: \"number\"");
}
void insert_container(const string& command, kind_of_type kind, istream& in) {
  skip_whitespace_but_not_newline(in);
  string name = next_word(in);
  if (name.find(':') != string::npos) {
    trace(9999, "parse") << "container has type ingredients; parsing" << end();
    read_type_ingredients(name);
  }

  // End container Name Refinements
  trace(9991, "parse") << "--- defining " << command << ' ' << name << end();
  if (!contains_key(Type_ordinal, name)
      || get(Type_ordinal, name) == 0) {
    put(Type_ordinal, name, Next_type_ordinal++);
  }
  trace(9999, "parse") << "type number: " << get(Type_ordinal, name) << end();
  skip_bracket(in, "'container' must begin with '['");
  type_info& info = get_or_insert(Type, get(Type_ordinal, name));
  Recently_added_types.push_back(get(Type_ordinal, name));
  info.name = name;
  info.kind = kind;
  while (has_data(in)) {
    skip_whitespace_and_comments(in);
    string element = next_word(in);
    if (element == "]") break;
    info.elements.push_back(reagent(element));
    replace_unknown_types_with_unique_ordinals(info.elements.back().type, info);
    trace(9993, "parse") << "  element: " << to_string(info.elements.back()) << end();
    {
      const type_tree* type = info.elements.back().type;
      if (type->name == "array") {
        if (!type->right) {
          raise_error << "container '" << name << "' doesn't specify type of array elements for " << info.elements.back().name << '\n' << end();
          continue;
        }
        if (!type->right->right) {  // array has no length
          raise_error << "container '" << name << "' cannot determine size of element " << info.elements.back().name << '\n' << end();
          continue;
        }
      }
    }


    // End Load Container Element Definition
  }
  info.size = SIZE(info.elements);
}

void replace_unknown_types_with_unique_ordinals(type_tree* type, const type_info& info) {
  if (!type) return;
  if (!type->name.empty()) {
    if (contains_key(Type_ordinal, type->name)) {
      type->value = get(Type_ordinal, type->name);
    }
    else if (is_integer(type->name)) {  // sometimes types will contain non-type tags, like numbers for the size of an array
      type->value = 0;
    }
    // check for use of type ingredients
    else if (is_type_ingredient_name(type->name)) {
      type->value = get(info.type_ingredient_names, type->name);
    }
    // End insert_container Special-cases
    else if (type->name != "->") {  // used in recipe types
      put(Type_ordinal, type->name, Next_type_ordinal++);
      type->value = get(Type_ordinal, type->name);
    }
  }
  replace_unknown_types_with_unique_ordinals(type->left, info);
  replace_unknown_types_with_unique_ordinals(type->right, info);
}

void skip_bracket(istream& in, string message) {
  skip_whitespace_and_comments(in);
  if (in.get() != '[')
    raise_error << message << '\n' << end();
}

void test_container_define_twice() {
  Trace_file = "container_define_twice";
  run("container foo [\n  x:number\n]\ncontainer foo [\n  y:number\n]\nrecipe main [\n  1:number <- copy 34\n  2:number <- copy 35\n  3:number <- get 1:foo, 0:offset\n  4:number <- get 1:foo, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 3mem: storing 35 in location 4");
}
void test_run_complains_on_unknown_types() {
  Trace_file = "run_complains_on_unknown_types";
  Hide_errors = true;
  run("recipe main [\n  # integer is not a type\n  1:integer <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: unknown type integer in '1:integer <- copy 0'");
}
void test_run_allows_type_definition_after_use() {
  Trace_file = "run_allows_type_definition_after_use";
  Hide_errors = true;
  run("recipe main [\n  1:bar <- copy 0/unsafe\n]\ncontainer bar [\n  x:number\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void check_or_set_invalid_types(const recipe_ordinal r) {
  recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- check for invalid types in recipe " << caller.name << end();
  for (long long int index = 0; index < SIZE(caller.steps); ++index) {
    instruction& inst = caller.steps.at(index);
    for (long long int i = 0; i < SIZE(inst.ingredients); ++i)
      check_or_set_invalid_types(inst.ingredients.at(i).type, maybe(caller.name), "'"+to_string(inst)+"'");
    for (long long int i = 0; i < SIZE(inst.products); ++i)
      check_or_set_invalid_types(inst.products.at(i).type, maybe(caller.name), "'"+to_string(inst)+"'");
  }
  for (long long int i = 0; i < SIZE(caller.ingredients); ++i)
    check_or_set_invalid_types(caller.ingredients.at(i).type, maybe(caller.name), "recipe header ingredient");
  for (long long int i = 0; i < SIZE(caller.products); ++i)
    check_or_set_invalid_types(caller.products.at(i).type, maybe(caller.name), "recipe header product");

  // End check_or_set_invalid_types
}

void check_or_set_invalid_types(type_tree* type, const string& block, const string& name) {
  if (!type) return;  // will throw a more precise error elsewhere
  if (type->value >= START_TYPE_INGREDIENTS
      && (type->value - START_TYPE_INGREDIENTS) < SIZE(get(Type, type->value).type_ingredient_names))
    return;
  // End Container Type Checks
  if (type->value == 0) return;
  if (!contains_key(Type, type->value)) {
    assert(!type->name.empty());
    if (contains_key(Type_ordinal, type->name))
      type->value = get(Type_ordinal, type->name);
    else
      raise_error << block << "unknown type " << type->name << " in " << name << '\n' << end();
  }
  check_or_set_invalid_types(type->left, block, name);
  check_or_set_invalid_types(type->right, block, name);
}

void test_container_unknown_field() {
  Trace_file = "container_unknown_field";
  Hide_errors = true;
  run("container foo [\n  x:number\n  y:bar\n]\n");
  CHECK_TRACE_CONTENTS("error: foo: unknown type in y");
}
void test_read_container_with_bracket_in_comment() {
  Trace_file = "read_container_with_bracket_in_comment";
  run("container foo [\n  x:number\n  # ']' in comment\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: --- defining container fooparse: element: x: \"number\"parse: element: y: \"number\"");
}
void check_container_field_types() {
  for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) {
    const type_info& info = p->second;
    if (!info.type_ingredient_names.empty()) continue;

    // Check Container Field Types(info)
    for (long long int i = 0; i < SIZE(info.elements); ++i)
      check_invalid_types(info.elements.at(i).type, maybe(info.name), info.elements.at(i).name);
  }
}

void check_invalid_types(const type_tree* type, const string& block, const string& name) {
  if (!type) return;  // will throw a more precise error elsewhere
  if (type->value >= START_TYPE_INGREDIENTS
      && (type->value - START_TYPE_INGREDIENTS) < SIZE(get(Type, type->value).type_ingredient_names))
    return;

  // End Container Type Checks2
  if (type->value == 0) {
    assert(!type->left && !type->right);
    return;
  }
  if (!contains_key(Type, type->value))
    raise_error << block << "unknown type in " << name << '\n' << end();
  check_invalid_types(type->left, block, name);
  check_invalid_types(type->right, block, name);
}


void test_merge() {
  Trace_file = "merge";
  run("container foo [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 3, 4\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 1mem: storing 4 in location 2");
}
void test_merge_check() {
  Trace_file = "merge_check";
  Hide_errors = true;
  run("recipe main [\n  1:point <- merge 3, 4\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_missing_element() {
  Trace_file = "merge_check_missing_element";
  Hide_errors = true;
  run("recipe main [\n  1:point <- merge 3\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too few ingredients in '1:point <- merge 3'");
}
void test_merge_check_extra_element() {
  Trace_file = "merge_check_extra_element";
  Hide_errors = true;
  run("recipe main [\n  1:point <- merge 3, 4, 5\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too many ingredients in '1:point <- merge 3, 4, 5'");
}
void test_merge_check_recursive_containers() {
  Trace_file = "merge_check_recursive_containers";
  Hide_errors = true;
  run("recipe main [\n  1:point <- merge 3, 4\n  1:point-number <- merge 1:point, 5\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_recursive_containers_2() {
  Trace_file = "merge_check_recursive_containers_2";
  Hide_errors = true;
  run("recipe main [\n  1:point <- merge 3, 4\n  2:point-number <- merge 1:point\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too few ingredients in '2:point-number <- merge 1:point'");
}
void test_merge_check_recursive_containers_3() {
  Trace_file = "merge_check_recursive_containers_3";
  Hide_errors = true;
  run("recipe main [\n  1:point-number <- merge 3, 4, 5\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_recursive_containers_4() {
  Trace_file = "merge_check_recursive_containers_4";
  Hide_errors = true;
  run("recipe main [\n  1:point-number <- merge 3, 4\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too few ingredients in '1:point-number <- merge 3, 4'");
}
void check_merge_calls(const recipe_ordinal r) {
  const recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- type-check merge instructions in recipe " << caller.name << end();
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    const instruction& inst = caller.steps.at(i);
    if (inst.name != "merge") continue;
    if (SIZE(inst.products) != 1) {
      raise_error << maybe(caller.name) << "'merge' should yield a single product in '" << to_string(inst) << "'\n" << end();
      continue;
    }
    reagent product = inst.products.at(0);
    // Update product While Type-checking Merge
    if (!canonize_type(product)) continue;

    type_ordinal product_type = product.type->value;
    if (product_type == 0 || !contains_key(Type, product_type)) {
      raise_error << maybe(caller.name) << "'merge' should yield a container in '" << to_string(inst) << "'\n" << end();
      continue;
    }
    const type_info& info = get(Type, product_type);
    if (info.kind != CONTAINER && info.kind != EXCLUSIVE_CONTAINER) {
      raise_error << maybe(caller.name) << "'merge' should yield a container in '" << to_string(inst) << "'\n" << end();
      continue;
    }
    check_merge_call(inst.ingredients, product, caller, inst);
  }
}

void check_merge_call(const vector<reagent>& ingredients, const reagent& product, const recipe& caller, const instruction& inst) {
  long long int ingredient_index = 0;
  merge_check_state state;
  state.data.push(merge_check_point(product, 0));
  while (true) {
    assert(!state.data.empty());
    trace(9999, "transform") << ingredient_index << " vs " << SIZE(ingredients) << end();
    if (ingredient_index >= SIZE(ingredients)) {
      raise_error << maybe(caller.name) << "too few ingredients in '" << to_string(inst) << "'\n" << end();
      return;
    }
    reagent& container = state.data.top().container;
    type_info& container_info = get(Type, container.type->value);
    switch (container_info.kind) {
      case CONTAINER: {
        reagent expected_ingredient = element_type(container, state.data.top().container_element_index);
        trace(9999, "transform") << "checking container " << to_string(container) << " || " << to_string(expected_ingredient) << " vs ingredient " << ingredient_index << end();
        // if the current element is the ingredient we expect, move on to the next element/ingredient
        if (types_coercible(expected_ingredient, ingredients.at(ingredient_index))) {
          ++ingredient_index;
          ++state.data.top().container_element_index;
          while (state.data.top().container_element_index >= SIZE(get(Type, state.data.top().container.type->value).elements)) {
            state.data.pop();
            if (state.data.empty()) {
              if (ingredient_index < SIZE(ingredients))
                raise_error << maybe(caller.name) << "too many ingredients in '" << to_string(inst) << "'\n" << end();
              return;
            }
            ++state.data.top().container_element_index;
          }
        }
        // if not, maybe it's a field of the current element
        else {
          // no change to ingredient_index
          state.data.push(merge_check_point(expected_ingredient, 0));
        }
        break;
      }
      case EXCLUSIVE_CONTAINER: {
        assert(state.data.top().container_element_index == 0);
        trace(9999, "transform") << "checking exclusive container " << to_string(container) << " vs ingredient " << ingredient_index << end();
        if (!is_literal(ingredients.at(ingredient_index))) {
          raise_error << maybe(caller.name) << "ingredient " << ingredient_index << " of 'merge' should be a literal, for the tag of exclusive-container " << container_info.name << '\n' << end();
          return;
        }
        reagent ingredient = ingredients.at(ingredient_index);  // unnecessary copy just to keep this function from modifying caller
        populate_value(ingredient);
        if (ingredient.value >= SIZE(container_info.elements)) {
          raise_error << maybe(caller.name) << "invalid tag at " << ingredient_index << " for " << container_info.name << " in '" << to_string(inst) << '\n' << end();
          return;
        }
        reagent variant = variant_type(container, ingredient.value);
        trace(9999, "transform") << "tag: " << ingredient.value << end();
        // replace union with its variant
        state.data.pop();
        state.data.push(merge_check_point(variant, 0));
        ++ingredient_index;
        break;
      }

      // End valid_merge Cases
      default: {
        if (!types_coercible(container, ingredients.at(ingredient_index))) {
          raise_error << maybe(caller.name) << "incorrect type of ingredient " << ingredient_index << " in '" << to_string(inst) << "'\n" << end();
          cerr << "  expected " << debug_string(container) << '\n';
          cerr << "  got " << debug_string(ingredients.at(ingredient_index)) << '\n';
          return;
        }
        ++ingredient_index;
        // ++state.data.top().container_element_index;  // unnecessary, but wouldn't do any harm
        do {
          state.data.pop();
          if (state.data.empty()) {
            if (ingredient_index < SIZE(ingredients))
              raise_error << maybe(caller.name) << "too many ingredients in '" << to_string(inst) << "'\n" << end();
            return;
          }
          ++state.data.top().container_element_index;
        } while (state.data.top().container_element_index >= SIZE(get(Type, state.data.top().container.type->value).elements));
      }
    }
  }
  // never gets here
  assert(false);
}

void test_merge_check_product() {
  Trace_file = "merge_check_product";
  Hide_errors = true;
  run("recipe main [\n  1:number <- merge 3\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'merge' should yield a container in '1:number <- merge 3'");
}

void test_copy_indirect() {
  Trace_file = "copy_indirect";
  run("recipe main [\n  1:address:number <- copy 2/unsafe\n  2:number <- copy 34\n  # This loads location 1 as an address and looks up *that* location.\n  3:number <- copy 1:address:number/lookup\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 3");
}
void test_store_indirect() {
  Trace_file = "store_indirect";
  run("recipe main [\n  1:address:number <- copy 2/unsafe\n  1:address:number/lookup <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
}
void test_store_to_0_fails() {
  Trace_file = "store_to_0_fails";
  Hide_errors = true;
  run("recipe main [\n  1:address:number <- copy 0\n  1:address:number/lookup <- copy 34\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 0");
  run("");
  CHECK_TRACE_CONTENTS("error: can't write to location 0 in '1:address:number/lookup <- copy 34'");
}
void canonize(reagent& x) {
  if (is_literal(x)) return;
    absolutize(x);
  // End canonize(x) Special-cases
  while (has_property(x, "lookup"))
    lookup_memory(x);
}

void lookup_memory(reagent& x) {
  if (!x.type || x.type->value != get(Type_ordinal, "address")) {
    raise_error << maybe(current_recipe_name()) << "tried to /lookup " << x.original_string << " but it isn't an address\n" << end();
    return;
  }
  // compute value
  if (x.value == 0) {
    raise_error << maybe(current_recipe_name()) << "tried to /lookup 0\n" << end();
    return;
  }
  trace(9999, "mem") << "location " << x.value << " is " << no_scientific(get_or_insert(Memory, x.value)) << end();
  x.set_value(get_or_insert(Memory, x.value));
  drop_from_type(x, "address");
  if (x.type->name == "shared") {
    trace(9999, "mem") << "skipping refcount at " << x.value << end();
    x.set_value(x.value+1);  // skip refcount
    drop_from_type(x, "shared");
  }
  // End Drop Address In lookup_memory(x)
  drop_one_lookup(x);
}

void test_canonize_non_pointer_fails_without_crashing() {
  Trace_file = "canonize_non_pointer_fails_without_crashing";
  Hide_errors = true;
  run("recipe foo [\n  1:address:number <- get-address *p, x:offset\n]\n# don't crash\n");
}
bool canonize_type(reagent& r) {
  while (has_property(r, "lookup")) {
    if (!r.type || r.type->value != get(Type_ordinal, "address")) {
      raise_error << "can't lookup non-address: " << to_string(r) << ": " << to_string(r.type) << '\n' << end();
      return false;
    }
    drop_from_type(r, "address");
    if (r.type->name == "shared") {
      drop_from_type(r, "shared");
    }

    // End Drop Address In canonize_type(r)
    drop_one_lookup(r);
  }
  return true;
}

void drop_from_type(reagent& r, string expected_type) {
  if (!r.type) {
    raise_error << "can't drop " << expected_type << " from " << to_string(r) << '\n' << end();
    return;
  }
  if (r.type->name != expected_type) {
    raise_error << "can't drop2 " << expected_type << " from " << to_string(r) << '\n' << end();
    return;
  }
  type_tree* tmp = r.type;
  r.type = tmp->right;
  tmp->right = NULL;
  delete tmp;
}

void drop_one_lookup(reagent& r) {
  for (vector<pair<string, string_tree*> >::iterator p = r.properties.begin(); p != r.properties.end(); ++p) {
    if (p->first == "lookup") {
      r.properties.erase(p);
      return;
    }
  }
  assert(false);
}

void test_get_indirect() {
  Trace_file = "get_indirect";
  run("recipe main [\n  1:number <- copy 2\n  2:number <- copy 34\n  3:number <- copy 35\n  4:number <- get 1:address:point/lookup, 0:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 4");
}
void test_get_indirect2() {
  Trace_file = "get_indirect2";
  run("recipe main [\n  1:number <- copy 2\n  2:number <- copy 34\n  3:number <- copy 35\n  4:address:number <- copy 5/unsafe\n  *4:address:number <- get 1:address:point/lookup, 0:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 5");
}
void test_include_nonlookup_properties() {
  Trace_file = "include_nonlookup_properties";
  run("recipe main [\n  1:number <- copy 2\n  2:number <- copy 34\n  3:number <- copy 35\n  4:number <- get 1:address:point/lookup/foo, 0:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 4");
}
void test_get_address_indirect() {
  Trace_file = "get_address_indirect";
  run("# 'get' can read from container address\nrecipe main [\n  1:number <- copy 2\n  2:number <- copy 34\n  3:number <- copy 35\n  4:address:number <- get-address 1:address:point/lookup, 0:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 4");
}
void test_lookup_abbreviation() {
  Trace_file = "lookup_abbreviation";
  run("recipe main [\n  1:address:number <- copy 2/unsafe\n  2:number <- copy 34\n  3:number <- copy *1:address:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: ingredient: 1: (\"address\" \"number\"), {\"lookup\": ()}mem: storing 34 in location 3");
}

void test_create_array() {
  Trace_file = "create_array";
  run("recipe main [\n  # create an array occupying locations 1 (for the size) and 2-4 (for the elements)\n  1:array:number:3 <- create-array\n]\n");
  CHECK_TRACE_CONTENTS("run: creating array of size 4");
}
void test_copy_array() {
  Trace_file = "copy_array";
  run("# Arrays can be copied around with a single instruction just like numbers,\n# no matter how large they are.\nrecipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:array:number <- copy 1:array:number:3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 5mem: storing 14 in location 6mem: storing 15 in location 7mem: storing 16 in location 8");
}
void test_copy_array_indirect() {
  Trace_file = "copy_array_indirect";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:address:array:number <- copy 1/unsafe\n  6:array:number <- copy *5:address:array:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 6mem: storing 14 in location 7mem: storing 15 in location 8mem: storing 16 in location 9");
}
void test_stash_array() {
  Trace_file = "stash_array";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  stash [foo:], 1:array:number:3\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: 3 14 15 16");
}
void test_container_contains_array() {
  Trace_file = "container_contains_array";
  Hide_errors = true;
  run("container foo [\n  x:array:number:3\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_container_warns_on_dynamic_array_element() {
  Trace_file = "container_warns_on_dynamic_array_element";
  Hide_errors = true;
  run("container foo [\n  x:array:number\n]\n");
  CHECK_TRACE_CONTENTS("error: container 'foo' cannot determine size of element x");
}
void test_index() {
  Trace_file = "index";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- index 1:array:number:3, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 5");
}
void test_index_direct_offset() {
  Trace_file = "index_direct_offset";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 0\n  6:number <- index 1:array:number, 5:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 6");
}
type_tree* array_element(const type_tree* type) {
  return type->right;
}

void test_index_indirect() {
  Trace_file = "index_indirect";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:address:array:number <- copy 1/unsafe\n  6:number <- index *5:address:array:number, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 15 in location 6");
}
void test_index_out_of_bounds() {
  Trace_file = "index_out_of_bounds";
  Hide_errors = true;
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  index *8:address:array:point, 4  # less than size of array in locations, but larger than its length in elements\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid index 4");
}
void test_index_out_of_bounds_2() {
  Trace_file = "index_out_of_bounds_2";
  Hide_errors = true;
  run("recipe main [\n  1:array:point:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  index *8:address:array:point, -1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid index -1");
}
void test_index_product_type_mismatch() {
  Trace_file = "index_product_type_mismatch";
  Hide_errors = true;
  run("recipe main [\n  1:array:point:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  9:number <- index *8:address:array:point, 0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'index' on *8:address:array:point can't be saved in 9:number; type should be point");
}
void test_index_without_product() {
  Trace_file = "index_without_product";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  index 1:array:number:3, 0\n]\n# just don't die\n");
}
void test_index_address() {
  Trace_file = "index_address";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:address:number <- index-address 1:array:number, 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 5");
}
void test_index_address_out_of_bounds() {
  Trace_file = "index_address_out_of_bounds";
  Hide_errors = true;
  run("recipe main [\n  1:array:point:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  index-address *8:address:array:point, 4  # less than size of array in locations, but larger than its length in elements\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid index 4");
}
void test_index_address_out_of_bounds_2() {
  Trace_file = "index_address_out_of_bounds_2";
  Hide_errors = true;
  run("recipe main [\n  1:array:point:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  index-address *8:address:array:point, -1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: invalid index -1");
}
void test_index_address_product_type_mismatch() {
  Trace_file = "index_address_product_type_mismatch";
  Hide_errors = true;
  run("recipe main [\n  1:array:point:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- copy 14\n  6:number <- copy 15\n  7:number <- copy 16\n  8:address:array:point <- copy 1/unsafe\n  9:address:number <- index-address *8:address:array:point, 0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'index' on *8:address:array:point can't be saved in 9:address:number; type should be (address point)");
}
void test_array_length() {
  Trace_file = "array_length";
  run("recipe main [\n  1:array:number:3 <- create-array\n  2:number <- copy 14\n  3:number <- copy 15\n  4:number <- copy 16\n  5:number <- length 1:array:number:3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 5");
}
bool is_mu_string(const reagent& x) {
  return x.type
    && x.type->value == get(Type_ordinal, "address")
    && x.type->right
    && x.type->right->value == get(Type_ordinal, "shared")
    && x.type->right->right
    && x.type->right->right->value == get(Type_ordinal, "array")
    && x.type->right->right->right
    && x.type->right->right->right->value == get(Type_ordinal, "character")
    && x.type->right->right->right->right == NULL;
}


void test_copy_exclusive_container() {
  Trace_file = "copy_exclusive_container";
  run("# Copying exclusive containers copies all their contents and an extra location for the tag.\nrecipe main [\n  1:number <- copy 1  # 'point' variant\n  2:number <- copy 34\n  3:number <- copy 35\n  4:number-or-point <- copy 1:number-or-point/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 4mem: storing 34 in location 5mem: storing 35 in location 6");
}
void test_maybe_convert() {
  Trace_file = "maybe_convert";
  run("recipe main [\n  12:number <- copy 1\n  13:number <- copy 35\n  14:number <- copy 36\n  20:address:point <- maybe-convert 12:number-or-point/unsafe, 1:variant\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 13 in location 20");
}
void test_maybe_convert_fail() {
  Trace_file = "maybe_convert_fail";
  run("recipe main [\n  12:number <- copy 1\n  13:number <- copy 35\n  14:number <- copy 36\n  20:address:number <- maybe-convert 12:number-or-point/unsafe, 0:variant\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 20");
}
const reagent variant_type(const reagent& canonized_base, long long int tag) {
  assert(tag >= 0);
  assert(contains_key(Type, canonized_base.type->value));
  assert(!get(Type, canonized_base.type->value).name.empty());
  const type_info& info = get(Type, canonized_base.type->value);
  assert(info.kind == EXCLUSIVE_CONTAINER);
  reagent element = info.elements.at(tag);
  if (contains_type_ingredient(element)) {
    if (!canonized_base.type->right)
      raise_error << "illegal type '" << to_string(canonized_base.type) << "' seems to be missing a type ingredient or three\n" << end();
    replace_type_ingredients(element.type, canonized_base.type->right, info);
  }

  // End variant_type Special-cases
  return element;
}

void test_maybe_convert_product_type_mismatch() {
  Trace_file = "maybe_convert_product_type_mismatch";
  Hide_errors = true;
  run("recipe main [\n  12:number <- copy 1\n  13:number <- copy 35\n  14:number <- copy 36\n  20:address:number <- maybe-convert 12:number-or-point/unsafe, 1:variant\n]\n");
  CHECK_TRACE_CONTENTS("error: main: 'maybe-convert 12:number-or-point/unsafe, 1:variant' should write to (address point) but 20 has type (address number)");
}
void test_exclusive_container() {
  Trace_file = "exclusive_container";
  run("exclusive-container foo [\n  x:number\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("parse: --- defining exclusive-container fooparse: element: x: \"number\"parse: element: y: \"number\"");
}
void test_exclusive_container_contains_array() {
  Trace_file = "exclusive_container_contains_array";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:array:number:3\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_exclusive_container_warns_on_dynamic_array_element() {
  Trace_file = "exclusive_container_warns_on_dynamic_array_element";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:array:number\n]\n");
  CHECK_TRACE_CONTENTS("error: container 'foo' cannot determine size of element x");
}
void test_lift_to_exclusive_container() {
  Trace_file = "lift_to_exclusive_container";
  run("exclusive-container foo [\n  x:number\n  y:number\n]\nrecipe main [\n  1:number <- copy 34\n  2:foo <- merge 0/x, 1:number  # tag must be a literal when merging exclusive containers\n  4:foo <- merge 1/y, 1:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2mem: storing 34 in location 3mem: storing 1 in location 4mem: storing 34 in location 5");
}
void test_merge_handles_exclusive_container() {
  Trace_file = "merge_handles_exclusive_container";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  z:number\n]\nrecipe main [\n  1:foo <- merge 0/x, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 34 in location 2");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_requires_literal_tag_for_exclusive_container() {
  Trace_file = "merge_requires_literal_tag_for_exclusive_container";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  z:number\n]\nrecipe main [\n  local-scope\n  1:number <- copy 0\n  2:foo <- merge 1:number, 34\n]\n");
  CHECK_TRACE_CONTENTS("error: main: ingredient 0 of 'merge' should be a literal, for the tag of exclusive-container foo");
}
void test_merge_check_container_containing_exclusive_container() {
  Trace_file = "merge_check_container_containing_exclusive_container";
  Hide_errors = true;
  run("container foo [\n  x:number\n  y:bar\n]\nexclusive-container bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 23, 1/y, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 23 in location 1mem: storing 1 in location 2mem: storing 34 in location 3");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_container_containing_exclusive_container_2() {
  Trace_file = "merge_check_container_containing_exclusive_container_2";
  Hide_errors = true;
  run("container foo [\n  x:number\n  y:bar\n]\nexclusive-container bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 23, 1/y, 34, 35\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too many ingredients in '1:foo <- merge 23, 1/y, 34, 35'");
}
void test_merge_check_exclusive_container_containing_container() {
  Trace_file = "merge_check_exclusive_container_containing_container";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 1/y, 23, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1mem: storing 23 in location 2mem: storing 34 in location 3");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_exclusive_container_containing_container_2() {
  Trace_file = "merge_check_exclusive_container_containing_container_2";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 0/x, 23\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_exclusive_container_containing_container_3() {
  Trace_file = "merge_check_exclusive_container_containing_container_3";
  Hide_errors = true;
  run("exclusive-container foo [\n  x:number\n  y:bar\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 1/y, 23\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too few ingredients in '1:foo <- merge 1/y, 23'");
}
void test_merge_exclusive_container_with_mismatched_sizes() {
  Trace_file = "merge_exclusive_container_with_mismatched_sizes";
  run("container foo [\n  x:number\n  y:number\n]\nexclusive-container bar [\n  x:number\n  y:foo\n]\nrecipe main [\n  1:number <- copy 34\n  2:number <- copy 35\n  3:bar <- merge 0/x, 1:number\n  6:bar <- merge 1/foo, 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3mem: storing 34 in location 4mem: storing 1 in location 6mem: storing 34 in location 7mem: storing 35 in location 8");
}

void test_calling_recipe() {
  Trace_file = "calling_recipe";
  run("recipe main [\n  f\n]\nrecipe f [\n  3:number <- add 2, 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 3");
}
void test_return_on_fallthrough() {
  Trace_file = "return_on_fallthrough";
  run("recipe main [\n  f\n  1:number <- copy 0\n  2:number <- copy 0\n  3:number <- copy 0\n]\nrecipe f [\n  4:number <- copy 0\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("run: frun: 4:number <- copy 0run: 5:number <- copy 0run: 1:number <- copy 0run: 2:number <- copy 0run: 3:number <- copy 0");
}
routine::routine(recipe_ordinal r) {
  if (Trace_stream) {
    ++Trace_stream->callstack_depth;
    trace(9999, "trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end();
    assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
  }
  calls.push_front(call(r));
  alloc = Memory_allocated_until;
  Memory_allocated_until += Initial_memory_per_routine;
  alloc_max = Memory_allocated_until;
  trace(9999, "new") << "routine allocated memory from " << alloc << " to " << alloc_max << end();

  global_space = 0;
  state = RUNNING;

  id = Next_routine_id;
  Next_routine_id++;

  parent_index = -1;

  limit = -1;  /* no limit */

  waiting_on_location = old_value_of_waiting_location = 0;


  waiting_on_routine = 0;

  // End routine Constructor
}

inline call& current_call() {
  return Current_routine->calls.front();
}


inline const instruction& to_instruction(const call& call) {
  return get(Recipe, call.running_recipe).steps.at(call.running_step_index);
}

void finish_call_housekeeping(const instruction& call_instruction, const vector<vector<double> >& ingredients) {
  for (long long int i = 0; i < SIZE(ingredients); ++i) {
    current_call().ingredient_atoms.push_back(ingredients.at(i));
    reagent ingredient = call_instruction.ingredients.at(i);
    canonize_type(ingredient);
    current_call().ingredients.push_back(ingredient);
  }

  // End Call Housekeeping
}

void test_calling_undefined_recipe_fails() {
  Trace_file = "calling_undefined_recipe_fails";
  Hide_errors = true;
  run("recipe main [\n  foo\n]\n");
  CHECK_TRACE_CONTENTS("error: main: undefined operation in 'foo '");
}
void test_calling_undefined_recipe_handles_missing_result() {
  Trace_file = "calling_undefined_recipe_handles_missing_result";
  Hide_errors = true;
  run("recipe main [\n  x:number <- foo\n]\n");
  CHECK_TRACE_CONTENTS("error: main: undefined operation in 'x:number <- foo '");
}

void test_next_ingredient() {
  Trace_file = "next_ingredient";
  run("recipe main [\n  f 2\n]\nrecipe f [\n  12:number <- next-ingredient\n  13:number <- add 1, 12:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 13");
}
void test_next_ingredient_missing() {
  Trace_file = "next_ingredient_missing";
  run("recipe main [\n  f\n]\nrecipe f [\n  _, 12:number <- next-ingredient\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 12");
}
void test_next_ingredient_fail_on_missing() {
  Trace_file = "next_ingredient_fail_on_missing";
  Hide_errors = true;
  run("recipe main [\n  f\n]\nrecipe f [\n  11:number <- next-ingredient\n]\n");
  CHECK_TRACE_CONTENTS("error: f: no ingredient to save in 11:number");
}
void test_rewind_ingredients() {
  Trace_file = "rewind_ingredients";
  run("recipe main [\n  f 2\n]\nrecipe f [\n  12:number <- next-ingredient  # consume ingredient\n  _, 1:boolean <- next-ingredient  # will not find any ingredients\n  rewind-ingredients\n  13:number, 2:boolean <- next-ingredient  # will find ingredient again\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 12mem: storing 0 in location 1mem: storing 2 in location 13mem: storing 1 in location 2");
}
void test_ingredient() {
  Trace_file = "ingredient";
  run("recipe main [\n  f 1, 2\n]\nrecipe f [\n  12:number <- ingredient 1  # consume second ingredient first\n  13:number, 1:boolean <- next-ingredient  # next-ingredient tries to scan past that\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 12mem: storing 0 in location 1");
}

void test_reply() {
  Trace_file = "reply";
  run("recipe main [\n  1:number, 2:number <- f 34\n]\nrecipe f [\n  12:number <- next-ingredient\n  13:number <- add 1, 12:number\n  reply 12:number, 13:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1mem: storing 35 in location 2");
}
void test_reply_container() {
  Trace_file = "reply_container";
  run("recipe main [\n  3:point <- f 2\n]\nrecipe f [\n  12:number <- next-ingredient\n  13:number <- copy 35\n  reply 12:point/raw\n]\n");
  CHECK_TRACE_CONTENTS("run: result 0 is [2, 35]mem: storing 2 in location 3mem: storing 35 in location 4");
}
void check_types_of_reply_instructions(recipe_ordinal r) {
  const recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- check types of reply instructions in recipe " << caller.name << end();
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    const instruction& caller_instruction = caller.steps.at(i);
    if (caller_instruction.is_label) continue;
    if (caller_instruction.products.empty()) continue;
    if (caller_instruction.operation < MAX_PRIMITIVE_RECIPES) continue;
    const recipe& callee = get(Recipe, caller_instruction.operation);
    for (long long int i = 0; i < SIZE(callee.steps); ++i) {
      const instruction& reply_inst = callee.steps.at(i);
      if (reply_inst.operation != REPLY) continue;
      // check types with the caller
      if (SIZE(caller_instruction.products) > SIZE(reply_inst.ingredients)) {
        raise_error << maybe(caller.name) << "too few values replied from " << callee.name << '\n' << end();
        break;
      }
      for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) {
        if (!types_coercible(caller_instruction.products.at(i), reply_inst.ingredients.at(i))) {
          raise_error << maybe(callee.name) << "reply ingredient " << reply_inst.ingredients.at(i).original_string << " can't be saved in " << caller_instruction.products.at(i).original_string << '\n' << end();
          reagent lhs = reply_inst.ingredients.at(i);
          canonize_type(lhs);
          reagent rhs = caller_instruction.products.at(i);
          canonize_type(rhs);
          raise_error << to_string(lhs.type) << " vs " << to_string(rhs.type) << '\n' << end();
          goto finish_reply_check;
        }
      }
      // check that any reply ingredients with /same-as-ingredient connect up
      // the corresponding ingredient and product in the caller.
      for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) {
        if (has_property(reply_inst.ingredients.at(i), "same-as-ingredient")) {
          string_tree* tmp = property(reply_inst.ingredients.at(i), "same-as-ingredient");
          if (!tmp || tmp->right) {
            raise_error << maybe(caller.name) << "'same-as-ingredient' metadata should take exactly one value in " << to_string(reply_inst) << '\n' << end();
            goto finish_reply_check;
          }
          long long int ingredient_index = to_integer(tmp->value);
          if (ingredient_index >= SIZE(caller_instruction.ingredients)) {
            raise_error << maybe(caller.name) << "too few ingredients in '" << to_string(caller_instruction) << "'\n" << end();
            goto finish_reply_check;
          }
          if (!is_dummy(caller_instruction.products.at(i)) && !is_literal(caller_instruction.ingredients.at(ingredient_index)) && caller_instruction.products.at(i).name != caller_instruction.ingredients.at(ingredient_index).name) {
            raise_error << maybe(caller.name) << "'" << to_string(caller_instruction) << "' should write to " << caller_instruction.ingredients.at(ingredient_index).original_string << " rather than " << caller_instruction.products.at(i).original_string << '\n' << end();
          }
        }
      }
      finish_reply_check:;
    }
  }
}

void test_reply_type_mismatch() {
  Trace_file = "reply_type_mismatch";
  Hide_errors = true;
  run("recipe main [\n  3:number <- f 2\n]\nrecipe f [\n  12:number <- next-ingredient\n  13:number <- copy 35\n  14:point <- copy 12:point/raw\n  reply 14:point\n]\n");
  CHECK_TRACE_CONTENTS("error: f: reply ingredient 14:point can't be saved in 3:number");
}
void test_reply_same_as_ingredient() {
  Trace_file = "reply_same_as_ingredient";
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy 0\n  2:number <- test1 1:number  # call with different ingredient and product\n]\nrecipe test1 [\n  10:number <- next-ingredient\n  reply 10:number/same-as-ingredient:0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: '2:number <- test1 1:number' should write to 1:number rather than 2:number");
}
void test_reply_same_as_ingredient_dummy() {
  Trace_file = "reply_same_as_ingredient_dummy";
  run("# % Hide_errors = true;\nrecipe main [\n  1:number <- copy 0\n  _ <- test1 1:number  # call with different ingredient and product\n]\nrecipe test1 [\n  10:number <- next-ingredient\n  reply 10:number/same-as-ingredient:0\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
string to_string(const vector<double>& in) {
  if (in.empty()) return "[]";
  ostringstream out;
  if (SIZE(in) == 1) {
    out << no_scientific(in.at(0));
    return out.str();
  }
  out << "[";
  for (long long int i = 0; i < SIZE(in); ++i) {
    if (i > 0) out << ", ";
    out << no_scientific(in.at(i));
  }
  out << "]";
  return out.str();
}


void test_reply_if() {
  Trace_file = "reply_if";
  run("recipe main [\n  1:number <- test1\n]\nrecipe test1 [\n  reply-if 0, 34\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 1");
}
void test_reply_if_2() {
  Trace_file = "reply_if_2";
  run("recipe main [\n  1:number <- test1\n]\nrecipe test1 [\n  reply-if 1, 34\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}


void test_new() {
  Trace_file = "new";
  run("# call new two times with identical arguments; you should get back different results\nrecipe main [\n  1:address:shared:number/raw <- new number:type\n  2:address:shared:number/raw <- new number:type\n  3:boolean/raw <- equal 1:address:shared:number/raw, 2:address:shared:number/raw\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
bool product_of_new_is_valid(const instruction& inst) {
  reagent product = inst.products.at(0);
  canonize_type(product);
  if (!product.type || product.type->value != get(Type_ordinal, "address")) return false;
  drop_from_type(product, "address");
  if (!product.type || product.type->value != get(Type_ordinal, "shared")) return false;
  drop_from_type(product, "shared");
  if (SIZE(inst.ingredients) > 1) {
    // array allocation
    if (!product.type || product.type->value != get(Type_ordinal, "array")) return false;
    drop_from_type(product, "array");
  }
  reagent expected_product("x:"+inst.ingredients.at(0).name);
  {
    string_tree* tmp_type_names = parse_string_tree(expected_product.type->name);
    delete expected_product.type;
    expected_product.type = new_type_tree(tmp_type_names);
    delete tmp_type_names;
  }
  // End Post-processing(expected_product) When Checking 'new'
  return types_strictly_match(product, expected_product);
}

void transform_new_to_allocate(const recipe_ordinal r) {
  trace(9991, "transform") << "--- convert 'new' to 'allocate' for recipe " << get(Recipe, r).name << end();
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    instruction& inst = get(Recipe, r).steps.at(i);
    if (inst.name == "new" && is_literal_string(inst.ingredients.at(0))) continue;
    // Convert 'new' To 'allocate'
    if (inst.name == "new") {
      inst.operation = ALLOCATE;
      string_tree* type_name = new string_tree(inst.ingredients.at(0).name);
      type_name = parse_string_tree(type_name);

      // End Post-processing(type_name) When Converting 'new'
      type_tree* type = new_type_tree(type_name);
      inst.ingredients.at(0).set_value(size_of(type));
      trace(9992, "new") << "size of " << to_string(type_name) << " is " << inst.ingredients.at(0).value << end();
      delete type;
      delete type_name;
    }
  }
}


void ensure_space(long long int size) {
  if (size > Initial_memory_per_routine) {
    tb_shutdown();
    cerr << "can't allocate " << size << " locations, that's too much compared to " << Initial_memory_per_routine << ".\n";
    exit(0);
  }
  if (Current_routine->alloc + size > Current_routine->alloc_max) {
    // waste the remaining space and create a new chunk
    Current_routine->alloc = Memory_allocated_until;
    Memory_allocated_until += Initial_memory_per_routine;
    Current_routine->alloc_max = Memory_allocated_until;
    trace(9999, "new") << "routine allocated memory from " << Current_routine->alloc << " to " << Current_routine->alloc_max << end();
  }
}

void test_new_initializes() {
  Trace_file = "new_initializes";
  Memory_allocated_until = 10;
  put(Memory, Memory_allocated_until, 1);
  run("recipe main [\n  1:address:shared:number <- new number:type\n  2:number <- copy *1:address:shared:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2");
}
void test_new_error() {
  Trace_file = "new_error";
  Hide_errors = true;
  run("recipe main [\n  1:address:number/raw <- new number:type\n]\n");
  CHECK_TRACE_CONTENTS("error: main: product of 'new' has incorrect type: 1:address:number/raw <- new number:type");
}
void test_new_array() {
  Trace_file = "new_array";
  run("recipe main [\n  1:address:shared:array:number/raw <- new number:type, 5\n  2:address:shared:number/raw <- new number:type\n  3:number/raw <- subtract 2:address:shared:number/raw, 1:address:shared:array:number/raw\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:array:number/raw <- new number:type, 5mem: array size is 5mem: storing 7 in location 3");
}
void test_new_empty_array() {
  Trace_file = "new_empty_array";
  run("recipe main [\n  1:address:shared:array:number/raw <- new number:type, 0\n  2:address:shared:number/raw <- new number:type\n  3:number/raw <- subtract 2:address:shared:number/raw, 1:address:shared:array:number/raw\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:array:number/raw <- new number:type, 0mem: array size is 0mem: storing 2 in location 3");
}
void test_new_overflow() {
  Trace_file = "new_overflow";
  Initial_memory_per_routine = 3;  // barely enough room for point allocation below
  run("recipe main [\n  1:address:shared:number/raw <- new number:type\n  2:address:shared:point/raw <- new point:type  # not enough room in initial page\n]\n");
  CHECK_TRACE_CONTENTS("new: routine allocated memory from 1000 to 1003new: routine allocated memory from 1003 to 1006");
}
void test_new_reclaim() {
  Trace_file = "new_reclaim";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  2:address:shared:number <- copy 1:address:shared:number  # because 1 will get reset during abandon below\n  abandon 1:address:shared:number  # unsafe\n  3:address:shared:number <- new number:type  # must be same size as abandoned memory to reuse\n  4:boolean <- equal 2:address:shared:number, 3:address:shared:number\n]\n# both allocations should have returned the same address\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 4");
}
void abandon(long long int address, long long int size) {
  trace(9999, "abandon") << "saving in free-list of size " << size << end();
//?   Total_free += size;
//?   Num_free++;
//?   cerr << "abandon: " << size << '\n';
  // clear memory
  for (long long int curr = address; curr < address+size; ++curr)
    put(Memory, curr, 0);
  // append existing free list to address
  put(Memory, address, get_or_insert(Free_list, size));
  put(Free_list, size, address);
}

void test_new_differing_size_no_reclaim() {
  Trace_file = "new_differing_size_no_reclaim";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  2:address:shared:number <- copy 1:address:shared:number\n  abandon 1:address:shared:number\n  3:address:shared:array:number <- new number:type, 2  # different size\n  4:boolean <- equal 2:address:shared:number, 3:address:shared:array:number\n]\n# no reuse\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 4");
}
void test_new_reclaim_array() {
  Trace_file = "new_reclaim_array";
  run("recipe main [\n  1:address:shared:array:number <- new number:type, 2\n  2:address:shared:array:number <- copy 1:address:shared:array:number\n  abandon 1:address:shared:array:number  # unsafe\n  3:address:shared:array:number <- new number:type, 2\n  4:boolean <- equal 2:address:shared:array:number, 3:address:shared:array:number\n]\n# reuse\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 4");
}
void test_reset_on_abandon() {
  Trace_file = "reset_on_abandon";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  abandon 1:address:shared:number\n]\n# reuse\n");
  CHECK_TRACE_CONTENTS("run: abandon 1:address:shared:numbermem: resetting location 1");
}
void test_refcounts() {
  Trace_file = "refcounts";
  run("recipe main [\n  1:address:shared:number <- copy 1000/unsafe\n  2:address:shared:number <- copy 1:address:shared:number\n  1:address:shared:number <- copy 0\n  2:address:shared:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:number <- copy 1000/unsafemem: incrementing refcount of 1000: 0 -> 1run: 2:address:shared:number <- copy 1:address:shared:numbermem: incrementing refcount of 1000: 1 -> 2run: 1:address:shared:number <- copy 0mem: decrementing refcount of 1000: 2 -> 1run: 2:address:shared:number <- copy 0mem: decrementing refcount of 1000: 1 -> 0mem: automatically abandoning 1000");
}
void test_refcounts_2() {
  Trace_file = "refcounts_2";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  # over-writing one allocation with another\n  1:address:shared:number <- new number:type\n  1:address:shared:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:number <- new number:typemem: incrementing refcount of 1000: 0 -> 1run: 1:address:shared:number <- new number:typemem: automatically abandoning 1000");
}
void test_refcounts_3() {
  Trace_file = "refcounts_3";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  # passing in addresses to recipes increments refcount\n  foo 1:address:shared:number\n  1:address:shared:number <- copy 0\n]\nrecipe foo [\n  2:address:shared:number <- next-ingredient\n  # return does NOT yet decrement refcount; memory must be explicitly managed\n  2:address:shared:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:number <- new number:typemem: incrementing refcount of 1000: 0 -> 1run: 2:address:shared:number <- next-ingredientmem: incrementing refcount of 1000: 1 -> 2run: 2:address:shared:number <- copy 0mem: decrementing refcount of 1000: 2 -> 1run: 1:address:shared:number <- copy 0mem: decrementing refcount of 1000: 1 -> 0mem: automatically abandoning 1000");
}
void test_refcounts_4() {
  Trace_file = "refcounts_4";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  # idempotent copies leave refcount unchanged\n  1:address:shared:number <- copy 1:address:shared:number\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:number <- new number:typemem: incrementing refcount of 1000: 0 -> 1run: 1:address:shared:number <- copy 1:address:shared:numbermem: decrementing refcount of 1000: 1 -> 0mem: incrementing refcount of 1000: 0 -> 1");
}
void test_refcounts_5() {
  Trace_file = "refcounts_5";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  # passing in addresses to recipes increments refcount\n  foo 1:address:shared:number\n  # return does NOT yet decrement refcount; memory must be explicitly managed\n  1:address:shared:number <- new number:type\n]\nrecipe foo [\n  2:address:shared:number <- next-ingredient\n]\n");
  CHECK_TRACE_CONTENTS("run: 1:address:shared:number <- new number:typemem: incrementing refcount of 1000: 0 -> 1run: 2:address:shared:number <- next-ingredientmem: incrementing refcount of 1000: 1 -> 2run: 1:address:shared:number <- new number:typemem: decrementing refcount of 1000: 2 -> 1");
}
void test_new_string() {
  Trace_file = "new_string";
  run("recipe main [\n  1:address:shared:array:character <- new [abc def]\n  2:character <- index *1:address:shared:array:character, 5\n]\n# number code for 'e'\n");
  CHECK_TRACE_CONTENTS("mem: storing 101 in location 2");
}
void test_new_string_handles_unicode() {
  Trace_file = "new_string_handles_unicode";
  run("recipe main [\n  1:address:shared:array:character <- new [a«c]\n  2:number <- length *1:address:shared:array:character\n  3:character <- index *1:address:shared:array:character, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 2mem: storing 171 in location 3");
}
long long int new_mu_string(const string& contents) {
  // allocate an array just large enough for it
  long long int string_length = unicode_length(contents);
//?   Total_alloc += string_length+1;
//?   Num_alloc++;
  ensure_space(string_length+1);  // don't forget the extra location for array size
  // initialize string
  long long int result = Current_routine->alloc;
  // initialize refcount
  put(Memory, Current_routine->alloc++, 0);
  // store length
  put(Memory, Current_routine->alloc++, string_length);
  long long int curr = 0;
  const char* raw_contents = contents.c_str();
  for (long long int i = 0; i < string_length; ++i) {
    uint32_t curr_character;
    assert(curr < SIZE(contents));
    tb_utf8_char_to_unicode(&curr_character, &raw_contents[curr]);
    put(Memory, Current_routine->alloc, curr_character);
    curr += tb_utf8_char_length(raw_contents[curr]);
    ++Current_routine->alloc;
  }
  // mu strings are not null-terminated in memory
  return result;
}


void test_stash_string() {
  Trace_file = "stash_string";
  run("recipe main [\n  1:address:shared:array:character <- new [abc]\n  stash [foo:], 1:address:shared:array:character\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: abc");
}
void test_unicode_string() {
  Trace_file = "unicode_string";
  run("recipe main [\n  1:address:shared:array:character <- new [♠]\n  stash [foo:], 1:address:shared:array:character\n]\n");
  CHECK_TRACE_CONTENTS("app: foo: ♠");
}
void test_stash_space_after_string() {
  Trace_file = "stash_space_after_string";
  run("recipe main [\n  1:address:shared:array:character <- new [abc]\n  stash 1:address:shared:array:character, [foo]\n]\n");
  CHECK_TRACE_CONTENTS("app: abc foo");
}
void test_new_string_overflow() {
  Trace_file = "new_string_overflow";
  Initial_memory_per_routine = 2;
  run("recipe main [\n  1:address:shared:number/raw <- new number:type\n  2:address:shared:array:character/raw <- new [a]  # not enough room in initial page, if you take the array size into account\n]\n");
  CHECK_TRACE_CONTENTS("new: routine allocated memory from 1000 to 1002new: routine allocated memory from 1002 to 1004");
}
long long int unicode_length(const string& s) {
  const char* in = s.c_str();
  long long int result = 0;
  long long int curr = 0;
  while (curr < SIZE(s)) {  // carefully bounds-check on the string
    // before accessing its raw pointer
    ++result;
    curr += tb_utf8_char_length(in[curr]);
  }
  return result;
}

string read_mu_string(long long int address) {
  if (address == 0) return "";
  address++;  // skip refcount
  long long int size = get_or_insert(Memory, address);
  if (size == 0) return "";
  ostringstream tmp;
  for (long long int curr = address+1; curr <= address+size; ++curr) {
    tmp << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr)));
  }
  return tmp.str();
}

bool is_mu_type_literal(reagent r) {
  return is_literal(r) && r.type && r.type->name == "type";
}

bool is_shared_address_of_array_of_numbers(reagent product) {
  canonize_type(product);
  if (!product.type || product.type->value != get(Type_ordinal, "address")) return false;
  drop_from_type(product, "address");
  if (!product.type || product.type->value != get(Type_ordinal, "shared")) return false;
  drop_from_type(product, "shared");
  if (!product.type || product.type->value != get(Type_ordinal, "array")) return false;
  drop_from_type(product, "array");
  if (!product.type || product.type->value != get(Type_ordinal, "number")) return false;
  return true;
}

void test_brace_conversion() {
  Trace_file = "brace_conversion";
  transform("recipe main [\n  {\n    break\n    1:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: jump 1:offsettransform: copy ...");
}
void transform_braces(const recipe_ordinal r) {
  const int OPEN = 0, CLOSE = 1;
  // use signed integer for step index because we'll be doing arithmetic on it
  list<pair<int/*OPEN/CLOSE*/, /*step*/long long int> > braces;
  trace(9991, "transform") << "--- transform braces for recipe " << get(Recipe, r).name << end();
//?   cerr << "--- transform braces for recipe " << get(Recipe, r).name << '\n';
  for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) {
    const instruction& inst = get(Recipe, r).steps.at(index);
    if (inst.label == "{") {
      trace(9993, "transform") << maybe(get(Recipe, r).name) << "push (open, " << index << ")" << end();
      braces.push_back(pair<int,long long int>(OPEN, index));
    }
    if (inst.label == "}") {
      trace(9993, "transform") << "push (close, " << index << ")" << end();
      braces.push_back(pair<int,long long int>(CLOSE, index));
    }
  }
  stack</*step*/long long int> open_braces;
  for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) {
    instruction& inst = get(Recipe, r).steps.at(index);
    if (inst.label == "{") {
      open_braces.push(index);
      continue;
    }
    if (inst.label == "}") {
      if (open_braces.empty()) {
        raise << "missing '{' in " << get(Recipe, r).name << '\n';
        return;
      }
      open_braces.pop();
      continue;
    }
    if (inst.is_label) continue;
    if (inst.old_name != "loop"
         && inst.old_name != "loop-if"
         && inst.old_name != "loop-unless"
         && inst.old_name != "break"
         && inst.old_name != "break-if"
         && inst.old_name != "break-unless") {
      trace(9992, "transform") << inst.old_name << " ..." << end();
      continue;
    }
    // check for errors
    if (inst.old_name.find("-if") != string::npos || inst.old_name.find("-unless") != string::npos) {
      if (inst.ingredients.empty()) {
        raise_error << inst.old_name << " expects 1 or 2 ingredients, but got none\n" << end();
        continue;
      }
    }
    // update instruction operation
    if (inst.old_name.find("-if") != string::npos) {
      inst.name = "jump-if";
      inst.operation = JUMP_IF;
    }
    else if (inst.old_name.find("-unless") != string::npos) {
      inst.name = "jump-unless";
      inst.operation = JUMP_UNLESS;
    }
    else {
      inst.name = "jump";
      inst.operation = JUMP;
    }
    // check for explicitly provided targets
    if (inst.old_name.find("-if") != string::npos || inst.old_name.find("-unless") != string::npos) {
      // conditional branches check arg 1
      if (SIZE(inst.ingredients) > 1 && is_literal(inst.ingredients.at(1))) {
        trace(9992, "transform") << inst.name << ' ' << inst.ingredients.at(1).name << ":offset" << end();
        continue;
      }
    }
    else {
      // unconditional branches check arg 0
      if (!inst.ingredients.empty() && is_literal(inst.ingredients.at(0))) {
        trace(9992, "transform") << "jump " << inst.ingredients.at(0).name << ":offset" << end();
        continue;
      }
    }
    // if implicit, compute target
    reagent target;
    target.type = new type_tree("offset", get(Type_ordinal, "offset"));
    target.set_value(0);
    if (open_braces.empty())
      raise_error << inst.old_name << " needs a '{' before\n" << end();
    else if (inst.old_name.find("loop") != string::npos)
      target.set_value(open_braces.top()-index);
    else  // break instruction
      target.set_value(matching_brace(open_braces.top(), braces, r) - index - 1);
    inst.ingredients.push_back(target);
    // log computed target
    if (inst.name == "jump")
      trace(9992, "transform") << "jump " << no_scientific(target.value) << ":offset" << end();
    else
      trace(9992, "transform") << inst.name << ' ' << inst.ingredients.at(0).name << ", " << no_scientific(target.value) << ":offset" << end();
  }
}

// returns a signed integer not just so that we can return -1 but also to
// enable future signed arithmetic
long long int matching_brace(long long int index, const list<pair<int, long long int> >& braces, recipe_ordinal r) {
  int stacksize = 0;
  for (list<pair<int, long long int> >::const_iterator p = braces.begin(); p != braces.end(); ++p) {
    if (p->second < index) continue;
    stacksize += (p->first ? 1 : -1);
    if (stacksize == 0) return p->second;
  }
  raise_error << maybe(get(Recipe, r).name) << "unbalanced '{'\n" << end();
  return SIZE(get(Recipe, r).steps);  // exit current routine
}

void test_loop() {
  Trace_file = "loop";
  transform("recipe main [\n  1:number <- copy 0\n  2:number <- copy 0\n  {\n    3:number <- copy 0\n    loop\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...transform: copy ...transform: jump -2:offset");
}
void test_break_empty_block() {
  Trace_file = "break_empty_block";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    break\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: jump 0:offset");
}
void test_break_cascading() {
  Trace_file = "break_cascading";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    break\n  }\n  {\n    break\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: jump 0:offsettransform: jump 0:offset");
}
void test_break_cascading_2() {
  Trace_file = "break_cascading_2";
  transform("recipe main [\n  1:number <- copy 0\n  2:number <- copy 0\n  {\n    break\n    3:number <- copy 0\n  }\n  {\n    break\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...transform: jump 1:offsettransform: copy ...transform: jump 0:offset");
}
void test_break_if() {
  Trace_file = "break_if";
  transform("recipe main [\n  1:number <- copy 0\n  2:number <- copy 0\n  {\n    break-if 2:number\n    3:number <- copy 0\n  }\n  {\n    break\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...transform: jump-if 2, 1:offsettransform: copy ...transform: jump 0:offset");
}
void test_break_nested() {
  Trace_file = "break_nested";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    2:number <- copy 0\n    break\n    {\n      3:number <- copy 0\n    }\n    4:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: jump 4:offset");
}
void test_break_nested_degenerate() {
  Trace_file = "break_nested_degenerate";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    2:number <- copy 0\n    break\n    {\n    }\n    4:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: jump 3:offset");
}
void test_break_nested_degenerate_2() {
  Trace_file = "break_nested_degenerate_2";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    2:number <- copy 0\n    break\n    {\n    }\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: jump 2:offset");
}
void test_break_label() {
  Trace_file = "break_label";
  Hide_errors = true;
  transform("recipe main [\n  1:number <- copy 0\n  {\n    break +foo:offset\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: jump +foo:offset");
}
void test_break_unless() {
  Trace_file = "break_unless";
  transform("recipe main [\n  1:number <- copy 0\n  2:number <- copy 0\n  {\n    break-unless 2:number\n    3:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...transform: jump-unless 2, 1:offsettransform: copy ...");
}
void test_loop_unless() {
  Trace_file = "loop_unless";
  transform("recipe main [\n  1:number <- copy 0\n  2:number <- copy 0\n  {\n    loop-unless 2:number\n    3:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...transform: jump-unless 2, -1:offsettransform: copy ...");
}
void test_loop_nested() {
  Trace_file = "loop_nested";
  transform("recipe main [\n  1:number <- copy 0\n  {\n    2:number <- copy 0\n    {\n      3:number <- copy 0\n    }\n    loop-if 4:boolean\n    5:number <- copy 0\n  }\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: jump-if 4, -5:offset");
}
void test_loop_label() {
  Trace_file = "loop_label";
  transform("recipe main [\n  1:number <- copy 0\n  +foo\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("transform: --- transform braces for recipe maintransform: copy ...transform: copy ...");
}
void test_brace_conversion_and_run() {
  Trace_file = "brace_conversion_and_run";
  run("recipe test-factorial [\n  1:number <- copy 5\n  2:number <- copy 1\n  {\n    3:boolean <- equal 1:number, 1\n    break-if 3:boolean\n#    $print 1:number\n    2:number <- multiply 2:number, 1:number\n    1:number <- subtract 1:number, 1\n    loop\n  }\n  4:number <- copy 2:number  # trigger a read\n]\n");
  CHECK_TRACE_CONTENTS("mem: location 2 is 120");
}
void test_break_outside_braces_fails() {
  Trace_file = "break_outside_braces_fails";
  Hide_errors = true;
  run("recipe main [\n  break\n]\n");
  CHECK_TRACE_CONTENTS("error: break needs a '{' before");
}
void test_break_conditional_without_ingredient_fails() {
  Trace_file = "break_conditional_without_ingredient_fails";
  Hide_errors = true;
  run("recipe main [\n  {\n    break-if\n  }\n]\n");
  CHECK_TRACE_CONTENTS("error: break-if expects 1 or 2 ingredients, but got none");
}

void test_jump_to_label() {
  Trace_file = "jump_to_label";
  run("recipe main [\n  jump +target:label\n  1:number <- copy 0\n  +target\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 1");
}
void transform_labels(const recipe_ordinal r) {
  map<string, long long int> offset;
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    const instruction& inst = get(Recipe, r).steps.at(i);
    if (!inst.label.empty() && inst.label.at(0) == '+') {
      if (!contains_key(offset, inst.label)) {
        put(offset, inst.label, i);
      }
      else {
        raise_error << maybe(get(Recipe, r).name) << "duplicate label '" << inst.label << "'" << end();
        // have all jumps skip some random but noticeable and deterministic amount of code
        put(offset, inst.label, 9999);
      }
    }
  }
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    instruction& inst = get(Recipe, r).steps.at(i);
    if (inst.name == "jump") {
      replace_offset(inst.ingredients.at(0), offset, i, r);
    }
    if (inst.name == "jump-if" || inst.name == "jump-unless") {
      replace_offset(inst.ingredients.at(1), offset, i, r);
    }
    if ((inst.name == "loop" || inst.name == "break")
        && SIZE(inst.ingredients) == 1) {
      replace_offset(inst.ingredients.at(0), offset, i, r);
    }
    if ((inst.name == "loop-if" || inst.name == "loop-unless"
            || inst.name == "break-if" || inst.name == "break-unless")
        && SIZE(inst.ingredients) == 2) {
      replace_offset(inst.ingredients.at(1), offset, i, r);
    }
  }
}

void replace_offset(reagent& x, /*const*/ map<string, long long int>& offset, const long long int current_offset, const recipe_ordinal r) {
  if (!is_literal(x)) {
    raise_error << maybe(get(Recipe, r).name) << "jump target must be offset or label but is " << x.original_string << '\n' << end();
    x.set_value(0);  // no jump by default
    return;
  }
  if (x.initialized) return;
  if (is_integer(x.name)) return;  // non-labels will be handled like other number operands
  if (!is_jump_target(x.name)) {
    raise_error << maybe(get(Recipe, r).name) << "can't jump to label " << x.name << '\n' << end();
    x.set_value(0);  // no jump by default
    return;
  }
  if (!contains_key(offset, x.name)) {
    raise_error << maybe(get(Recipe, r).name) << "can't find label " << x.name << '\n' << end();
    x.set_value(0);  // no jump by default
    return;
  }
  x.set_value(get(offset, x.name) - current_offset);
}

bool is_jump_target(string label) {
  return label.at(0) == '+';
}

void test_break_to_label() {
  Trace_file = "break_to_label";
  run("recipe main [\n  {\n    {\n      break +target:label\n      1:number <- copy 0\n    }\n  }\n  +target\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 1");
}
void test_jump_if_to_label() {
  Trace_file = "jump_if_to_label";
  run("recipe main [\n  {\n    {\n      jump-if 1, +target:label\n      1:number <- copy 0\n    }\n  }\n  +target\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 1");
}
void test_loop_unless_to_label() {
  Trace_file = "loop_unless_to_label";
  run("recipe main [\n  {\n    {\n      loop-unless 0, +target:label  # loop/break with a label don't care about braces\n      1:number <- copy 0\n    }\n  }\n  +target\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 1");
}
void test_jump_runs_code_after_label() {
  Trace_file = "jump_runs_code_after_label";
  run("recipe main [\n  # first a few lines of padding to exercise the offset computation\n  1:number <- copy 0\n  2:number <- copy 0\n  3:number <- copy 0\n  jump +target:label\n  4:number <- copy 0\n  +target\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 5");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 4");
}
void test_recipe_fails_on_duplicate_jump_target() {
  Trace_file = "recipe_fails_on_duplicate_jump_target";
  Hide_errors = true;
  run("recipe main [\n  +label\n  1:number <- copy 0\n  +label\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: duplicate label '+label'");
}
void test_jump_ignores_nontarget_label() {
  Trace_file = "jump_ignores_nontarget_label";
  Hide_errors = true;
  run("recipe main [\n  # first a few lines of padding to exercise the offset computation\n  1:number <- copy 0\n  2:number <- copy 0\n  3:number <- copy 0\n  jump $target:label\n  4:number <- copy 0\n  $target\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't jump to label $target");
}

void test_transform_names() {
  Trace_file = "transform_names";
  run("recipe main [\n  x:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("name: assign x 1mem: storing 0 in location 1");
}
void test_transform_names_fails_on_use_before_define() {
  Trace_file = "transform_names_fails_on_use_before_define";
  Hide_errors = true;
  transform("recipe main [\n  x:number <- copy y:number\n]\n");
  CHECK_TRACE_CONTENTS("error: main: use before set: y");
}
void transform_names(const recipe_ordinal r) {
  recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- transform names for recipe " << caller.name << end();
//?   cerr << "--- transform names for recipe " << caller.name << '\n';
  bool names_used = false;
  bool numeric_locations_used = false;
  map<string, long long int>& names = Name[r];
  // store the indices 'used' so far in the map
  long long int& curr_idx = names[""];
  ++curr_idx;  // avoid using index 0, benign skip in some other cases
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    instruction& inst = caller.steps.at(i);
    // replace element names of containers with offsets
    if (inst.name == "get" || inst.name == "get-address") {
      if (SIZE(inst.ingredients) != 2) {
        raise_error << maybe(get(Recipe, r).name) << "exactly 2 ingredients expected in '" << to_string(inst) << "'\n" << end();
        break;
      }
      if (!is_literal(inst.ingredients.at(1)))
        raise_error << maybe(get(Recipe, r).name) << "expected ingredient 1 of " << (inst.name == "get" ? "'get'" : "'get-address'") << " to have type 'offset'; got " << inst.ingredients.at(1).original_string << '\n' << end();
      if (inst.ingredients.at(1).name.find_first_not_of("0123456789") != string::npos) {
        // since first non-address in base type must be a container, we don't have to canonize
        type_ordinal base_type = skip_addresses(inst.ingredients.at(0).type, get(Recipe, r).name);
        if (contains_key(Type, base_type)) {  // otherwise we'll raise an error elsewhere
          inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name, get(Recipe, r).name));
          trace(9993, "name") << "element " << inst.ingredients.at(1).name << " of type " << get(Type, base_type).name << " is at offset " << no_scientific(inst.ingredients.at(1).value) << end();
        }
      }
    }

    // convert variant names of exclusive containers
    if (inst.name == "maybe-convert") {
      if (SIZE(inst.ingredients) != 2) {
        raise_error << maybe(get(Recipe, r).name) << "exactly 2 ingredients expected in '" << to_string(inst) << "'\n" << end();
        break;
      }
      assert(is_literal(inst.ingredients.at(1)));
      if (inst.ingredients.at(1).name.find_first_not_of("0123456789") != string::npos) {
        // since first non-address in base type must be an exclusive container, we don't have to canonize
        type_ordinal base_type = skip_addresses(inst.ingredients.at(0).type, get(Recipe, r).name);
        if (contains_key(Type, base_type)) {  // otherwise we'll raise an error elsewhere
          inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name, get(Recipe, r).name));
          trace(9993, "name") << "variant " << inst.ingredients.at(1).name << " of type " << get(Type, base_type).name << " has tag " << no_scientific(inst.ingredients.at(1).value) << end();
        }
      }
    }

    // End transform_names(inst) Special-cases
    // map names to addresses
    for (long long int in = 0; in < SIZE(inst.ingredients); ++in) {
      if (is_disqualified(inst.ingredients.at(in), inst, caller.name)) continue;
      if (is_numeric_location(inst.ingredients.at(in))) numeric_locations_used = true;
      if (is_named_location(inst.ingredients.at(in))) names_used = true;
      if (is_integer(inst.ingredients.at(in).name)) continue;
      if (!already_transformed(inst.ingredients.at(in), names)) {
        raise_error << maybe(caller.name) << "use before set: " << inst.ingredients.at(in).name << '\n' << end();
      }
      inst.ingredients.at(in).set_value(lookup_name(inst.ingredients.at(in), r));
    }
    for (long long int out = 0; out < SIZE(inst.products); ++out) {
      if (is_disqualified(inst.products.at(out), inst, caller.name)) continue;
      if (is_numeric_location(inst.products.at(out))) numeric_locations_used = true;
      if (is_named_location(inst.products.at(out))) names_used = true;
      if (is_integer(inst.products.at(out).name)) continue;
      if (names.find(inst.products.at(out).name) == names.end()) {
        trace(9993, "name") << "assign " << inst.products.at(out).name << " " << curr_idx << end();
        names[inst.products.at(out).name] = curr_idx;
        curr_idx += size_of(inst.products.at(out));
      }
      inst.products.at(out).set_value(lookup_name(inst.products.at(out), r));
    }
  }
  if (names_used && numeric_locations_used)
    raise_error << maybe(caller.name) << "mixing variable names and numeric addresses\n" << end();
}

bool is_disqualified(/*mutable*/ reagent& x, const instruction& inst, const string& recipe_name) {
  if (!x.type) {
    if (!x.type && contains_key(Recipe_ordinal, x.name)) {
      x.type = new type_tree("recipe-literal", get(Type_ordinal, "recipe-literal"));
      x.set_value(get(Recipe_ordinal, x.name));
      return true;
    }

    // End Null-type is_disqualified Exceptions
    raise_error << maybe(recipe_name) << "missing type for " << x.original_string << " in '" << to_string(inst) << "'\n" << end();
    return true;
  }
  if (is_raw(x)) return true;
  if (is_literal(x)) return true;
  if (x.name == "default-space")
    x.initialized = true;
  if (x.name == "number-of-locals")
    x.initialized = true;
  if (x.name == "global-space")
    x.initialized = true;
  // End is_disqualified Cases
  if (x.initialized) return true;
  return false;
}

bool already_transformed(const reagent& r, const map<string, long long int>& names) {
  if (has_property(r, "space")) {
    string_tree* p = property(r, "space");
    if (!p || p->right) {
      raise_error << "/space property should have exactly one (non-negative integer) value in " << r.original_string << '\n' << end();
      return false;
    }
    if (p->value != "0") return true;
  }
  return contains_key(names, r.name);
}


long long int lookup_name(const reagent& x, const recipe_ordinal default_recipe) {
  if (!has_property(x, "space")) {
    if (Name[default_recipe].empty()) raise_error << "name not found: " << x.name << '\n' << end();
    return Name[default_recipe][x.name];
  }
  string_tree* p = property(x, "space");
  if (!p || p->right) raise_error << "/space property should have exactly one (non-negative integer) value\n" << end();
  long long int n = to_integer(p->value);
  assert(n >= 0);
  recipe_ordinal surrounding_recipe = lookup_surrounding_recipe(default_recipe, n);
  set<recipe_ordinal> done;
  vector<recipe_ordinal> path;
  return lookup_name(x, surrounding_recipe, done, path);
}

// If the recipe we need to lookup this name in doesn't have names done yet,
// recursively call transform_names on it.
long long int lookup_name(const reagent& x, const recipe_ordinal r, set<recipe_ordinal>& done, vector<recipe_ordinal>& path) {
  if (!Name[r].empty()) return Name[r][x.name];
  if (contains_key(done, r)) {
    raise_error << "can't compute address of " << to_string(x) << " because " << end();
    for (long long int i = 1; i < SIZE(path); ++i) {
      raise_error << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end();
    }
    raise_error << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end();
    return 0;
  }
  done.insert(r);
  path.push_back(r);
  transform_names(r);  // Not passing 'done' through. Might this somehow cause an infinite loop?
  assert(!Name[r].empty());
  return Name[r][x.name];
}

recipe_ordinal lookup_surrounding_recipe(const recipe_ordinal r, long long int n) {
  if (n == 0) return r;
  if (!contains_key(Surrounding_space, r)) {
    raise_error << "don't know surrounding recipe of " << get(Recipe, r).name << '\n' << end();
    return 0;
  }
  assert(contains_key(Surrounding_space, r));
  return lookup_surrounding_recipe(get(Surrounding_space, r), n-1);
}


type_ordinal skip_addresses(type_tree* type, const string& recipe_name) {
  type_ordinal address = get(Type_ordinal, "address");
  type_ordinal shared = get(Type_ordinal, "shared");
  for (; type; type = type->right) {
    if (type->value != address && type->value != shared)
      return type->value;
  }
  raise_error << maybe(recipe_name) << "expected a container" << '\n' << end();
  return -1;
}

int find_element_name(const type_ordinal t, const string& name, const string& recipe_name) {
  const type_info& container = get(Type, t);
  for (long long int i = 0; i < SIZE(container.elements); ++i)
    if (container.elements.at(i).name == name) return i;
  raise_error << maybe(recipe_name) << "unknown element " << name << " in container " << get(Type, t).name << '\n' << end();
  return -1;
}

bool is_numeric_location(const reagent& x) {
  if (is_global(x)) return false;


  if (is_literal(x)) return false;
  if (is_raw(x)) return false;
  if (x.name == "0") return false;  // used for chaining lexical scopes
  return is_integer(x.name);
}

bool is_named_location(const reagent& x) {
  if (is_literal(x)) return false;
  if (is_raw(x)) return false;
  if (is_special_name(x.name)) return false;
  return !is_integer(x.name);
}

bool is_special_name(const string& s) {
  if (s == "_") return true;
  if (s == "0") return true;
  if (s == "default-space") return true;

  if (s == "number-of-locals") return true;

  if (s == "global-space") return true;

  if (s == "screen") return true;

  if (s == "console") return true;

  // End is_special_name Cases
  return false;
}

void test_transform_names_passes_dummy() {
  Trace_file = "transform_names_passes_dummy";
  transform("# _ is just a dummy result that never gets consumed\nrecipe main [\n  _, x:number <- copy 0, 1\n]\n");
  CHECK_TRACE_CONTENTS("name: assign x 1");
  CHECK_TRACE_DOESNT_CONTAIN("name: assign _ 1");
}
void test_transform_names_passes_raw() {
  Trace_file = "transform_names_passes_raw";
  Hide_errors = true;
  run("recipe main [\n  x:number/raw <- copy 0\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("name: assign x 1");
  run("");
  CHECK_TRACE_CONTENTS("error: can't write to location 0 in 'x:number/raw <- copy 0'");
}
void test_transform_names_fails_when_mixing_names_and_numeric_locations() {
  Trace_file = "transform_names_fails_when_mixing_names_and_numeric_locations";
  Hide_errors = true;
  transform("recipe main [\n  x:number <- copy 1:number\n]\n");
  CHECK_TRACE_CONTENTS("error: main: mixing variable names and numeric addresses");
}
void test_transform_names_fails_when_mixing_names_and_numeric_locations_2() {
  Trace_file = "transform_names_fails_when_mixing_names_and_numeric_locations_2";
  Hide_errors = true;
  transform("recipe main [\n  x:number <- copy 1\n  1:number <- copy x:number\n]\n");
  CHECK_TRACE_CONTENTS("error: main: mixing variable names and numeric addresses");
}
void test_transform_names_does_not_fail_when_mixing_names_and_raw_locations() {
  Trace_file = "transform_names_does_not_fail_when_mixing_names_and_raw_locations";
  Hide_errors = true;
  transform("recipe main [\n  x:number <- copy 1:number/raw\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("error: main: mixing variable names and numeric addresses");
  CHECK_TRACE_COUNT("error", 0);
}
void test_transform_names_does_not_fail_when_mixing_names_and_literals() {
  Trace_file = "transform_names_does_not_fail_when_mixing_names_and_literals";
  Hide_errors = true;
  transform("recipe main [\n  x:number <- copy 1\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("error: main: mixing variable names and numeric addresses");
  CHECK_TRACE_COUNT("error", 0);
}
void test_transform_names_transforms_container_elements() {
  Trace_file = "transform_names_transforms_container_elements";
  transform("recipe main [\n  p:address:point <- copy 0\n  a:number <- get *p:address:point, y:offset\n  b:number <- get *p:address:point, x:offset\n]\n");
  CHECK_TRACE_CONTENTS("name: element y of type point is at offset 1name: element x of type point is at offset 0");
}
void test_transform_names_handles_containers() {
  Trace_file = "transform_names_handles_containers";
  transform("recipe main [\n  a:point <- copy 0/unsafe\n  b:number <- copy 0/unsafe\n]\n");
  CHECK_TRACE_CONTENTS("name: assign a 1name: assign b 3");
}
void test_transform_names_handles_exclusive_containers() {
  Trace_file = "transform_names_handles_exclusive_containers";
  run("recipe main [\n  12:number <- copy 1\n  13:number <- copy 35\n  14:number <- copy 36\n  20:address:point <- maybe-convert 12:number-or-point/unsafe, p:variant\n]\n");
  CHECK_TRACE_CONTENTS("name: variant p of type number-or-point has tag 1mem: storing 13 in location 20");
}

void test_set_default_space() {
  Trace_file = "set_default_space";
  run("# if default-space is 10, and if an array of 5 locals lies from location 12 to 16 (inclusive),\n# then local 0 is really location 12, local 1 is really location 13, and so on.\nrecipe main [\n  # pretend shared:array:location; in practice we'll use new\n  10:number <- copy 0  # refcount\n  11:number <- copy 5  # length\n  default-space:address:shared:array:location <- copy 10/unsafe\n  1:number <- copy 23\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 23 in location 13");
}
void test_lookup_sidesteps_default_space() {
  Trace_file = "lookup_sidesteps_default_space";
  run("recipe main [\n  # pretend pointer from outside\n  3:number <- copy 34\n  # pretend shared:array:location; in practice we'll use new\n  1000:number <- copy 0  # refcount\n  1001:number <- copy 5  # length\n  # actual start of this recipe\n  default-space:address:shared:array:location <- copy 1000/unsafe\n  1:address:number <- copy 3/unsafe\n  8:number/raw <- copy *1:address:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 8");
}
void test_convert_names_passes_default_space() {
  Trace_file = "convert_names_passes_default_space";
  Hide_errors = true;
  run("recipe main [\n  default-space:number, x:number <- copy 0, 1\n]\n");
  CHECK_TRACE_CONTENTS("name: assign x 1");
  CHECK_TRACE_DOESNT_CONTAIN("name: assign default-space 1");
}
void absolutize(reagent& x) {
  if (is_raw(x) || is_dummy(x)) return;
  if (x.name == "default-space") return;
  if (!x.initialized) {
    raise_error << to_string(current_instruction()) << ": reagent not initialized: " << x.original_string << '\n' << end();
  }
  x.set_value(address(x.value, space_base(x)));
  x.properties.push_back(pair<string, string_tree*>("raw", NULL));
  assert(is_raw(x));
}

long long int space_base(const reagent& x) {
  if (is_global(x)) {
    if (!Current_routine->global_space)
      raise_error << "routine has no global space\n" << end();
    return Current_routine->global_space + /*skip refcount*/1;
  }


  long long int base = current_call().default_space ? (current_call().default_space+/*skip refcount*/1) : 0;
  return space_base(x, space_index(x), base);
}

long long int space_base(const reagent& x, long long int space_index, long long int base) {
//?   trace(9999, "space") << "space-base: " << space_index << " " << base << end();
  if (space_index == 0) {
    return base;
  }
  long long int result = space_base(x, space_index-1, get_or_insert(Memory, base+/*skip length*/1))+/*skip refcount*/1;
//?   trace(9999, "space") << "space-base: " << space_index << " " << base << " => " << result << end();
  return result;
}

long long int space_index(const reagent& x) {
  for (long long int i = 0; i < SIZE(x.properties); ++i) {
    if (x.properties.at(i).first == "space") {
      if (!x.properties.at(i).second || x.properties.at(i).second->right)
        raise_error << maybe(current_recipe_name()) << "/space metadata should take exactly one value in " << x.original_string << '\n' << end();
      return to_integer(x.properties.at(i).second->value);
    }
  }
  return 0;
}


long long int address(long long int offset, long long int base) {
  if (base == 0) return offset;  // raw
  long long int size = get_or_insert(Memory, base);
  if (offset >= size) {
    // todo: test
    raise_error << "location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
    return 0;
  }
  return base + /*skip length*/1 + offset;
}


void test_get_default_space() {
  Trace_file = "get_default_space";
  run("recipe main [\n  default-space:address:shared:array:location <- copy 10/unsafe\n  1:address:shared:array:location/raw <- copy default-space:address:shared:array:location\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1");
}
void test_lookup_sidesteps_default_space_in_get() {
  Trace_file = "lookup_sidesteps_default_space_in_get";
  run("recipe main [\n  # pretend pointer to container from outside\n  12:number <- copy 34\n  13:number <- copy 35\n  # pretend shared:array:location; in practice we'll use new\n  1000:number <- copy 0  # refcount\n  1001:number <- copy 5  # length\n  # actual start of this recipe\n  default-space:address:shared:array:location <- copy 1000/unsafe\n  1:address:point <- copy 12/unsafe\n  9:number/raw <- get *1:address:point, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 9");
}
void test_lookup_sidesteps_default_space_in_index() {
  Trace_file = "lookup_sidesteps_default_space_in_index";
  run("recipe main [\n  # pretend pointer to array from outside\n  12:number <- copy 2\n  13:number <- copy 34\n  14:number <- copy 35\n  # pretend shared:array:location; in practice we'll use new\n  1000:number <- copy 0  # refcount\n  1001:number <- copy 5  # length\n  # actual start of this recipe\n  default-space:address:shared:array:location <- copy 1000/unsafe\n  1:address:array:number <- copy 12/unsafe\n  9:number/raw <- index *1:address:array:number, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 9");
}
void test_new_default_space() {
  Trace_file = "new_default_space";
  run("recipe main [\n  new-default-space\n  x:number <- copy 0\n  y:number <- copy 3\n]\n# allocate space for x and y, as well as the chaining slot at 0\n");
  CHECK_TRACE_CONTENTS("mem: array size is 3");
}
void test_local_scope() {
  Trace_file = "local_scope";
  run("recipe main [\n  1:address <- foo\n  2:address <- foo\n  3:boolean <- equal 1:address, 2:address\n]\nrecipe foo [\n  local-scope\n  x:number <- copy 34\n  reply default-space:address:shared:array:location\n]\n# both calls to foo should have received the same default-space\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void try_reclaim_locals() {
  // only reclaim routines starting with 'local-scope'
  const recipe_ordinal r = get(Recipe_ordinal, current_recipe_name());
  if (get(Recipe, r).steps.empty()) return;
  const instruction& inst = get(Recipe, r).steps.at(0);
  if (inst.old_name != "local-scope") return;
  abandon(current_call().default_space,
          /*refcount*/1 + /*array length*/1 + /*number-of-locals*/Name[r][""]);
}

void rewrite_default_space_instruction(instruction& curr) {
  if (!curr.ingredients.empty())
    raise_error << to_string(curr) << " can't take any ingredients\n" << end();
  curr.name = "new";
  curr.ingredients.push_back(reagent("location:type"));
  curr.ingredients.push_back(reagent("number-of-locals:literal"));
  if (!curr.products.empty())
    raise_error << "new-default-space can't take any results\n" << end();
  curr.products.push_back(reagent("default-space:address:shared:array:location"));
}


void check_default_space(const recipe_ordinal r) {
  if (!Warn_on_missing_default_space) return;  // skip previous core tests; this is only for mu code
  const recipe& caller = get(Recipe, r);
  // skip scenarios (later layer)
  // user code should never create recipes with underscores in their names
  if (caller.name.find("scenario_") == 0) return;  // skip mu scenarios which will use raw memory locations
  if (caller.name.find("run_") == 0) return;  // skip calls to 'run', which should be in scenarios and will also use raw memory locations
  // assume recipes with only numeric addresses know what they're doing (usually tests)
  if (!contains_non_special_name(r)) return;
  trace(9991, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
  if (caller.steps.empty()) return;
  if (caller.steps.at(0).products.empty()
      || caller.steps.at(0).products.at(0).name != "default-space") {
    raise << maybe(caller.name) << " does not seem to start with default-space or local-scope\n" << end();
//?     cerr << maybe(caller.name) << " does not seem to start with default-space or local-scope\n" << '\n';
  }
}
bool contains_non_special_name(const recipe_ordinal r) {
  for (map<string, long long int>::iterator p = Name[r].begin(); p != Name[r].end(); ++p) {
    if (p->first.empty()) continue;
    if (p->first.find("stash_") == 0) continue;  // generated by rewrite_stashes_to_text (cross-layer)
    if (!is_special_name(p->first)) {
//?       cerr << "  " << get(Recipe, r).name << ": " << p->first << '\n';
      return true;
    }
  }
  return false;
}


void test_surrounding_space() {
  Trace_file = "surrounding_space";
  run("# location 1 in space 1 refers to the space surrounding the default space, here 20.\nrecipe main [\n  # pretend shared:array:location; in practice we'll use new\n  10:number <- copy 0  # refcount\n  11:number <- copy 5  # length\n  # pretend shared:array:location; in practice we'll use new\n  20:number <- copy 0  # refcount\n  21:number <- copy 5  # length\n  # actual start of this recipe\n  default-space:address:shared:array:location <- copy 10/unsafe\n  0:address:shared:array:location/names:dummy <- copy 20/unsafe  # later layers will explain the /names: property\n  1:number <- copy 32\n  1:number/space:1 <- copy 33\n]\nrecipe dummy [  # just for the /names: property above\n]\n# chain space: 10 + /*skip refcount*/1 + /*skip length*/1\n");
  CHECK_TRACE_CONTENTS("mem: storing 20 in location 12mem: storing 32 in location 13mem: storing 33 in location 23");
}
void test_permit_space_as_variable_name() {
  Trace_file = "permit_space_as_variable_name";
  run("recipe main [\n  space:number <- copy 0\n]\n");
}

void test_closure() {
  Trace_file = "closure";
  run("recipe main [\n  default-space:address:shared:array:location <- new location:type, 30\n  1:address:shared:array:location/names:new-counter <- new-counter\n  2:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter\n  3:number/raw <- increment-counter 1:address:shared:array:location/names:new-counter\n]\nrecipe new-counter [\n  default-space:address:shared:array:location <- new location:type, 30\n  x:number <- copy 23\n  y:number <- copy 3  # variable that will be incremented\n  reply default-space:address:shared:array:location\n]\nrecipe increment-counter [\n  default-space:address:shared:array:location <- new location:type, 30\n  0:address:shared:array:location/names:new-counter <- next-ingredient  # outer space must be created by 'new-counter' above\n  y:number/space:1 <- add y:number/space:1, 1  # increment\n  y:number <- copy 234  # dummy\n  reply y:number/space:1\n]\n");
  CHECK_TRACE_CONTENTS("name: lexically surrounding space for recipe increment-counter comes from new-countermem: storing 5 in location 3");
}
void collect_surrounding_spaces(const recipe_ordinal r) {
  trace(9991, "transform") << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << end();
//?   cerr << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << '\n';
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    const instruction& inst = get(Recipe, r).steps.at(i);
    if (inst.is_label) continue;
    for (long long int j = 0; j < SIZE(inst.products); ++j) {
      if (is_literal(inst.products.at(j))) continue;
      if (inst.products.at(j).name != "0") continue;
      type_tree* type = inst.products.at(j).type;
      if (!type
          || type->value != get(Type_ordinal, "address")
          || !type->right
          || type->right->value != get(Type_ordinal, "shared")
          || !type->right->right
          || type->right->right->value != get(Type_ordinal, "array")
          || !type->right->right->right
          || type->right->right->right->value != get(Type_ordinal, "location")
          || type->right->right->right->right) {
        raise_error << "slot 0 should always have type address:shared:array:location, but is " << to_string(inst.products.at(j)) << '\n' << end();
        continue;
      }
      string_tree* s = property(inst.products.at(j), "names");
      if (!s) {
        raise_error << "slot 0 requires a /names property in recipe " << get(Recipe, r).name << end();
        continue;
      }
      if (s->right) raise_error << "slot 0 should have a single value in /names, but got " << to_string(inst.products.at(j)) << '\n' << end();
      const string& surrounding_recipe_name = s->value;
      if (surrounding_recipe_name.empty()) {
        raise_error << "slot 0 doesn't initialize its /names property in recipe " << get(Recipe, r).name << end();
        continue;
      }
      if (contains_key(Surrounding_space, r)
          && get(Surrounding_space, r) != get(Recipe_ordinal, surrounding_recipe_name)) {
        raise_error << "recipe " << get(Recipe, r).name << " can have only one 'surrounding' recipe but has " << get(Recipe, get(Surrounding_space, r)).name << " and " << surrounding_recipe_name << '\n' << end();
        continue;
      }
      trace(9993, "name") << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << end();
//?       cerr << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << '\n';
      if (!contains_key(Recipe_ordinal, surrounding_recipe_name)) {
        raise << "can't find recipe providing surrounding space for " << get(Recipe, r).name << ": " << surrounding_recipe_name << '\n' << end();
        continue;
      }
      put(Surrounding_space, r, get(Recipe_ordinal, surrounding_recipe_name));
    }
  }
}


// So far we have local variables, and we can nest local variables of short
// lifetimes inside longer ones. Now let's support 'global' variables that
// last for the life of a routine. If we create multiple routines they won't
// have access to each other's globals.

void test_global_space() {
  Trace_file = "global_space";
  run("recipe main [\n  # pretend shared:array:location; in practice we'll use new\n  10:number <- copy 0  # refcount\n  11:number <- copy 5  # length\n  # pretend shared:array:location; in practice we'll use new\n  20:number <- copy 0  # refcount\n  21:number <- copy 5  # length\n  # actual start of this recipe\n  global-space:address:shared:array:location <- copy 20/unsafe\n  default-space:address:shared:array:location <- copy 10/unsafe\n  1:number <- copy 23\n  1:number/space:global <- copy 24\n]\n# store to default space: 10 + /*skip refcount*/1 + /*skip length*/1 + /*index*/1\n");
  CHECK_TRACE_CONTENTS("mem: storing 23 in location 13mem: storing 24 in location 23");
}
void test_global_space_with_names() {
  Trace_file = "global_space_with_names";
  Hide_errors = true;
  run("recipe main [\n  global-space:address:shared:array:location <- new location:type, 10\n  x:number <- copy 23\n  1:number/space:global <- copy 24\n]\n# don't complain about mixing numeric addresses and names\n");
  CHECK_TRACE_COUNT("error", 0);
}
bool is_global(const reagent& x) {
  for (long long int i = 0; i < SIZE(x.properties); ++i) {
    if (x.properties.at(i).first == "space")
      return x.properties.at(i).second && x.properties.at(i).second->value == "global";
  }
  return false;
}


void test_transform_fails_on_reusing_name_with_different_type() {
  Trace_file = "transform_fails_on_reusing_name_with_different_type";
  Hide_errors = true;
  run("recipe main [\n  x:number <- copy 1\n  x:boolean <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("error: main: x used with multiple types");
}
void check_or_set_types_by_name(const recipe_ordinal r) {
  trace(9991, "transform") << "--- deduce types for recipe " << get(Recipe, r).name << end();
  map<string, type_tree*> type;
  for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
    instruction& inst = get(Recipe, r).steps.at(i);
    for (long long int in = 0; in < SIZE(inst.ingredients); ++in) {
      deduce_missing_type(type, inst.ingredients.at(in));
      check_type(type, inst.ingredients.at(in), r);
    }
    for (long long int out = 0; out < SIZE(inst.products); ++out) {
      deduce_missing_type(type, inst.products.at(out));
      check_type(type, inst.products.at(out), r);
    }
  }
}

void deduce_missing_type(map<string, type_tree*>& type, reagent& x) {
  if (x.type) return;
  if (!contains_key(type, x.name)) return;
  x.type = new type_tree(*get(type, x.name));
  trace(9992, "transform") << x.name << " <= " << names_to_string(x.type) << end();
}

void check_type(map<string, type_tree*>& type, const reagent& x, const recipe_ordinal r) {
  if (is_literal(x)) return;
  if (is_integer(x.name)) return;  // if you use raw locations you're probably doing something unsafe
  if (!x.type) return;  // might get filled in by other logic later
  if (!contains_key(type, x.name)) {
    trace(9992, "transform") << x.name << " => " << names_to_string(x.type) << end();
    put(type, x.name, x.type);
  }
  if (!types_strictly_match(get(type, x.name), x.type)) {
    raise_error << maybe(get(Recipe, r).name) << x.name << " used with multiple types\n" << end();
    return;
  }
  if (get(type, x.name)->name == "array") {
    if (!get(type, x.name)->right) {
      raise_error << maybe(get(Recipe, r).name) << x.name << " can't be just an array. What is it an array of?\n" << end();
      return;
    }
    if (!get(type, x.name)->right->right) {
      raise_error << get(Recipe, r).name << " can't determine the size of array variable " << x.name << ". Either allocate it separately and make the type of " << x.name << " address:shared:..., or specify the length of the array in the type of " << x.name << ".\n" << end();
      return;
    }
  }
}

void test_transform_fills_in_missing_types() {
  Trace_file = "transform_fills_in_missing_types";
  run("recipe main [\n  x:number <- copy 1\n  y:number <- add x, 1\n]\n");
}
void test_transform_fills_in_missing_types_in_product() {
  Trace_file = "transform_fills_in_missing_types_in_product";
  run("recipe main [\n  x:number <- copy 1\n  x <- copy 2\n]\n");
}
void test_transform_fills_in_missing_types_in_product_and_ingredient() {
  Trace_file = "transform_fills_in_missing_types_in_product_and_ingredient";
  run("recipe main [\n  x:number <- copy 1\n  x <- add x, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_transform_fails_on_missing_types_in_first_mention() {
  Trace_file = "transform_fails_on_missing_types_in_first_mention";
  Hide_errors = true;
  run("recipe main [\n  x <- copy 1\n  x:number <- copy 2\n]\n");
  CHECK_TRACE_CONTENTS("error: main: missing type for x in 'x <- copy 1'");
}
void test_typo_in_address_type_fails() {
  Trace_file = "typo_in_address_type_fails";
  Hide_errors = true;
  run("recipe main [\n  y:address:shared:charcter <- new character:type\n  *y <- copy 67\n]\n");
  CHECK_TRACE_CONTENTS("error: main: unknown type charcter in 'y:address:shared:charcter <- new character:type'");
}
void test_array_type_without_size_fails() {
  Trace_file = "array_type_without_size_fails";
  Hide_errors = true;
  run("recipe main [\n  x:array:number <- merge 2, 12, 13\n]\n");
  CHECK_TRACE_CONTENTS("error: main can't determine the size of array variable x. Either allocate it separately and make the type of x address:shared:..., or specify the length of the array in the type of x.");
}

scenario parse_scenario(istream& in) {
  scenario result;
  result.name = next_word(in);
  if (contains_key(Scenario_names, result.name))
    raise_error << "duplicate scenario name: " << result.name << '\n' << end();
  Scenario_names.insert(result.name);
  skip_whitespace_and_comments(in);
  assert(in.peek() == '[');
  // scenarios are take special 'code' strings so we need to ignore brackets
  // inside comments
  result.to_run = slurp_quoted(in);
  // delete [] delimiters
  assert(result.to_run.at(0) == '[');
  result.to_run.erase(0, 1);
  assert(result.to_run.at(SIZE(result.to_run)-1) == ']');
  result.to_run.erase(SIZE(result.to_run)-1);
  return result;
}

void test_warn_on_redefine_scenario() {
  Trace_file = "warn_on_redefine_scenario";
  Hide_warnings = true;
  Disable_redefine_warnings = true;
  run("recipe scenario-foo [\n  1:number <- copy 34\n]\nrecipe scenario-foo [\n  1:number <- copy 35\n]\n");
  CHECK_TRACE_CONTENTS("warn: redefining recipe scenario-foo");
}
void test_run() {
  Trace_file = "run";
  run("recipe main [\n  run [\n    1:number <- copy 13\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 13 in location 1");
}
void bind_special_scenario_names(recipe_ordinal r) {
  // Special Scenario Variable Names(r)
  Name[r]["screen"] = SCREEN;

  Name[r]["console"] = CONSOLE;

  // End Special Scenario Variable Names(r)
}

void test_run_multiple() {
  Trace_file = "run_multiple";
  run("recipe main [\n  run [\n    1:number <- copy 13\n  ]\n  run [\n    2:number <- copy 13\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 13 in location 1mem: storing 13 in location 2");
}
void test_memory_check() {
  Trace_file = "memory_check";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  memory-should-contain [\n    1 <- 13\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("run: checking location 1error: expected location 1 to contain 13 but saw 0");
}
void check_memory(const string& s) {
  istringstream in(s);
  in >> std::noskipws;
  set<long long int> locations_checked;
  while (true) {
    skip_whitespace_and_comments(in);
    if (!has_data(in)) break;
    string lhs = next_word(in);
    if (!is_integer(lhs)) {
      check_type(lhs, in);
      continue;
    }
    long long int address = to_integer(lhs);
    skip_whitespace_and_comments(in);
    string _assign;  in >> _assign;  assert(_assign == "<-");
    skip_whitespace_and_comments(in);
    double value = 0;  in >> value;
    if (contains_key(locations_checked, address))
      raise_error << "duplicate expectation for location " << address << '\n' << end();
    trace(9999, "run") << "checking location " << address << end();
    if (get_or_insert(Memory, address) != value) {
      if (Current_scenario && !Scenario_testing_scenario) {
        // genuine test in a mu file
        raise_error << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
      }
      else {
        // just testing scenario support
        raise_error << "expected location " << address << " to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
      }
      if (!Scenario_testing_scenario) {
        Passed = false;
        ++Num_failures;
      }
      return;
    }
    locations_checked.insert(address);
  }
}

void check_type(const string& lhs, istream& in) {
  reagent x(lhs);
  if (x.type->name == "array"
      && x.type->right && x.type->right->name == "character"
      && !x.type->right->right) {
    x.set_value(to_integer(x.name));
    skip_whitespace_and_comments(in);
    string _assign = next_word(in);
    assert(_assign == "<-");
    skip_whitespace_and_comments(in);
    string literal = next_word(in);
    long long int address = x.value;
    // exclude quoting brackets
    assert(*literal.begin() == '[');  literal.erase(literal.begin());
    assert(*--literal.end() == ']');  literal.erase(--literal.end());
    check_string(address, literal);
    return;
  }
  raise_error << "don't know how to check memory for " << lhs << '\n' << end();
}

void check_string(long long int address, const string& literal) {
  trace(9999, "run") << "checking string length at " << address << end();
  if (get_or_insert(Memory, address) != SIZE(literal)) {
    if (Current_scenario && !Scenario_testing_scenario)
      raise_error << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << " (" << read_mu_string(address) << ")\n" << end();
    else
      raise_error << "expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end();
    if (!Scenario_testing_scenario) {
      Passed = false;
      ++Num_failures;
    }
    return;
  }
  ++address;  // now skip length
  for (long long int i = 0; i < SIZE(literal); ++i) {
    trace(9999, "run") << "checking location " << address+i << end();
    if (get_or_insert(Memory, address+i) != literal.at(i)) {
      if (Current_scenario && !Scenario_testing_scenario) {
        // genuine test in a mu file
        raise_error << "\nF - " << Current_scenario->name << ": expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << " ('" << static_cast<char>(get_or_insert(Memory, address+i)) << "')\n" << end();
      }
      else {
        // just testing scenario support
        raise_error << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << '\n' << end();
      }
      if (!Scenario_testing_scenario) {
        Passed = false;
        ++Num_failures;
      }
      return;
    }
  }
}

void test_memory_check_multiple() {
  Trace_file = "memory_check_multiple";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  memory-should-contain [\n    1 <- 0\n    1 <- 0\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: duplicate expectation for location 1");
}
void test_memory_check_string_length() {
  Trace_file = "memory_check_string_length";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy 3\n  2:number <- copy 97  # 'a'\n  3:number <- copy 98  # 'b'\n  4:number <- copy 99  # 'c'\n  memory-should-contain [\n    1:array:character <- [ab]\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: expected location 1 to contain length 2 of string [ab] but saw 3");
}
void test_memory_check_string() {
  Trace_file = "memory_check_string";
  run("recipe main [\n  1:number <- copy 3\n  2:number <- copy 97  # 'a'\n  3:number <- copy 98  # 'b'\n  4:number <- copy 99  # 'c'\n  memory-should-contain [\n    1:array:character <- [abc]\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("run: checking string length at 1run: checking location 2run: checking location 3run: checking location 4");
}
// Like runs of contiguous '+' lines, order is important. The trace checks
// that the lines are present *and* in the specified sequence. (There can be
// other lines in between.)

void test_trace_check_fails() {
  Trace_file = "trace_check_fails";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  trace-should-contain [\n    a: b\n    a: d\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: missing [b] in trace with label a");
}
// simplified version of check_trace_contents() that emits errors rather
// than just printing to stderr
void check_trace(const string& expected) {
  Trace_stream->newline();
  vector<trace_line> expected_lines = parse_trace(expected);
  if (expected_lines.empty()) return;
  long long int curr_expected_line = 0;
  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    if (expected_lines.at(curr_expected_line).label != p->label) continue;
    if (expected_lines.at(curr_expected_line).contents != trim(p->contents)) continue;
    // match
    ++curr_expected_line;
    if (curr_expected_line == SIZE(expected_lines)) return;
  }

  raise_error << "missing [" << expected_lines.at(curr_expected_line).contents << "] "
              << "in trace with label " << expected_lines.at(curr_expected_line).label << '\n' << end();
  Passed = false;
}

vector<trace_line> parse_trace(const string& expected) {
  vector<string> buf = split(expected, "\n");
  vector<trace_line> result;
  for (long long int i = 0; i < SIZE(buf); ++i) {
    buf.at(i) = trim(buf.at(i));
    if (buf.at(i).empty()) continue;
    long long int delim = buf.at(i).find(": ");
    result.push_back(trace_line(trim(buf.at(i).substr(0, delim)),  trim(buf.at(i).substr(delim+2))));
  }
  return result;
}

void test_trace_check_fails_in_nonfirst_line() {
  Trace_file = "trace_check_fails_in_nonfirst_line";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  run [\n    trace 1, [a], [b]\n  ]\n  trace-should-contain [\n    a: b\n    a: d\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: missing [d] in trace with label a");
}
void test_trace_check_passes_silently() {
  Trace_file = "trace_check_passes_silently";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  run [\n    trace 1, [a], [b]\n  ]\n  trace-should-contain [\n    a: b\n  ]\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("error: missing [b] in trace with label a");
  CHECK_TRACE_COUNT("error", 0);
}
void test_trace_negative_check_fails() {
  Trace_file = "trace_negative_check_fails";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  run [\n    trace 1, [a], [b]\n  ]\n  trace-should-not-contain [\n    a: b\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: unexpected [b] in trace with label a");
}
// simplified version of check_trace_contents() that emits errors rather
// than just printing to stderr
bool check_trace_missing(const string& in) {
  Trace_stream->newline();
  vector<trace_line> lines = parse_trace(in);
  for (long long int i = 0; i < SIZE(lines); ++i) {
    if (trace_count(lines.at(i).label, lines.at(i).contents) != 0) {
      raise_error << "unexpected [" << lines.at(i).contents << "] in trace with label " << lines.at(i).label << '\n' << end();
      Passed = false;
      return false;
    }
  }
  return true;
}

void test_trace_negative_check_passes_silently() {
  Trace_file = "trace_negative_check_passes_silently";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  trace-should-not-contain [\n    a: b\n  ]\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("error: unexpected [b] in trace with label a");
  CHECK_TRACE_COUNT("error", 0);
}
void test_trace_negative_check_fails_on_any_unexpected_line() {
  Trace_file = "trace_negative_check_fails_on_any_unexpected_line";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  run [\n    trace 1, [a], [d]\n  ]\n  trace-should-not-contain [\n    a: b\n    a: d\n  ]\n]\n");
  CHECK_TRACE_CONTENTS("error: unexpected [d] in trace with label a");
}
void test_trace_count_check() {
  Trace_file = "trace_count_check";
  run("recipe main [\n  run [\n    trace 1, [a], [foo]\n  ]\n  check-trace-count-for-label 1, [a]\n]\n");
}
void test_trace_count_check_2() {
  Trace_file = "trace_count_check_2";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  run [\n    trace 1, [a], [foo]\n  ]\n  check-trace-count-for-label 2, [a]\n]\n");
  CHECK_TRACE_CONTENTS("error: main: expected 2 lines in trace with label a in trace");
}

void test_tangle_before() {
  Trace_file = "tangle_before";
  run("recipe main [\n  1:number <- copy 0\n  <label1>\n  3:number <- copy 0\n]\nbefore <label1> [\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 0 in location 2mem: storing 0 in location 3");
  CHECK_TRACE_COUNT("mem", 3);
}
void insert_fragments(const recipe_ordinal r) {
  bool made_progress = true;
  long long int pass = 0;
  while (made_progress) {
    made_progress = false;
    // create a new vector because insertions invalidate iterators
    vector<instruction> result;
    for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) {
      const instruction& inst = get(Recipe, r).steps.at(i);
      if (!inst.is_label || !is_waypoint(inst.label) || inst.tangle_done) {
        result.push_back(inst);
        continue;
      }
      inst.tangle_done = true;
      made_progress = true;
      Fragments_used.insert(inst.label);
      ostringstream prefix;
      prefix << '+' << get(Recipe, r).name << '_' << pass << '_' << i;
      // ok to use contains_key even though Before_fragments uses [],
      // because appending an empty recipe is a noop
      if (contains_key(Before_fragments, inst.label))
        append_fragment(result, Before_fragments[inst.label].steps, prefix.str());
      result.push_back(inst);
      if (contains_key(After_fragments, inst.label))
        append_fragment(result, After_fragments[inst.label].steps, prefix.str());
    }
    get(Recipe, r).steps.swap(result);
    ++pass;
  }
}

void append_fragment(vector<instruction>& base, const vector<instruction>& patch, const string prefix) {
  // append 'patch' to 'base' while keeping 'base' oblivious to any new jump
  // targets in 'patch' oblivious to 'base' by prepending 'prefix' to them.
  // we might tangle the same fragment at multiple points in a single recipe,
  // and we need to avoid duplicate jump targets.
  // so we'll keep jump targets local to the specific before/after fragment
  // that introduces them.
  set<string> jump_targets;
  for (long long int i = 0; i < SIZE(patch); ++i) {
    const instruction& inst = patch.at(i);
    if (inst.is_label && is_jump_target(inst.label))
      jump_targets.insert(inst.label);
  }
  for (long long int i = 0; i < SIZE(patch); ++i) {
    instruction inst = patch.at(i);
    if (inst.is_label) {
      if (contains_key(jump_targets, inst.label))
        inst.label = prefix+inst.label;
      base.push_back(inst);
      continue;
    }
    for (long long int j = 0; j < SIZE(inst.ingredients); ++j) {
      reagent& x = inst.ingredients.at(j);
      if (!is_literal(x)) continue;
      if (x.type->name == "label" && contains_key(jump_targets, x.name))
        x.name = prefix+x.name;
    }
    base.push_back(inst);
  }
}

bool is_waypoint(string label) {
  return *label.begin() == '<' && *label.rbegin() == '>';
}

void check_insert_fragments(unused recipe_ordinal) {
  if (Transform_check_insert_fragments_Ran) return;
  Transform_check_insert_fragments_Ran = true;
  for (map<string, recipe>::iterator p = Before_fragments.begin(); p != Before_fragments.end(); ++p) {
    if (!contains_key(Fragments_used, p->first))
      raise_error << "could not locate insert before " << p->first << '\n' << end();
  }
  for (map<string, recipe>::iterator p = After_fragments.begin(); p != After_fragments.end(); ++p) {
    if (!contains_key(Fragments_used, p->first))
      raise_error << "could not locate insert after " << p->first << '\n' << end();
  }
}

void test_tangle_before_and_after() {
  Trace_file = "tangle_before_and_after";
  run("recipe main [\n  1:number <- copy 0\n  <label1>\n  4:number <- copy 0\n]\nbefore <label1> [\n  2:number <- copy 0\n]\nafter <label1> [\n  3:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 0 in location 2mem: storing 0 in location 3mem: storing 0 in location 4");
  CHECK_TRACE_COUNT("mem", 4);
}
void test_tangle_ignores_jump_target() {
  Trace_file = "tangle_ignores_jump_target";
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy 0\n  +label1\n  4:number <- copy 0\n]\nbefore +label1 [\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("error: can't tangle before label +label1");
}
void test_tangle_keeps_labels_separate() {
  Trace_file = "tangle_keeps_labels_separate";
  run("recipe main [\n  1:number <- copy 0\n  <label1>\n  <label2>\n  6:number <- copy 0\n]\nbefore <label1> [\n  2:number <- copy 0\n]\nafter <label1> [\n  3:number <- copy 0\n]\nbefore <label2> [\n  4:number <- copy 0\n]\nafter <label2> [\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 0 in location 2mem: storing 0 in location 3mem: storing 0 in location 4mem: storing 0 in location 5mem: storing 0 in location 6");
  CHECK_TRACE_COUNT("mem", 6);
}
void test_tangle_stacks_multiple_fragments() {
  Trace_file = "tangle_stacks_multiple_fragments";
  run("recipe main [\n  1:number <- copy 0\n  <label1>\n  6:number <- copy 0\n]\nbefore <label1> [\n  2:number <- copy 0\n]\nafter <label1> [\n  3:number <- copy 0\n]\nbefore <label1> [\n  4:number <- copy 0\n]\nafter <label1> [\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 0 in location 2mem: storing 0 in location 4mem: storing 0 in location 5mem: storing 0 in location 3mem: storing 0 in location 6");
  CHECK_TRACE_COUNT("mem", 6);
}
void test_tangle_supports_fragments_with_multiple_instructions() {
  Trace_file = "tangle_supports_fragments_with_multiple_instructions";
  run("recipe main [\n  1:number <- copy 0\n  <label1>\n  6:number <- copy 0\n]\nbefore <label1> [\n  2:number <- copy 0\n  3:number <- copy 0\n]\nafter <label1> [\n  4:number <- copy 0\n  5:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 0 in location 2mem: storing 0 in location 3mem: storing 0 in location 4mem: storing 0 in location 5mem: storing 0 in location 6");
  CHECK_TRACE_COUNT("mem", 6);
}
void test_tangle_tangles_into_all_labels_with_same_name() {
  Trace_file = "tangle_tangles_into_all_labels_with_same_name";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  4:number <- copy 10\n  recipe2\n]\nrecipe recipe2 [\n  1:number <- copy 11\n  <label1>\n  4:number <- copy 11\n]\nbefore <label1> [\n  2:number <- copy 12\n]\nafter <label1> [\n  3:number <- copy 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 10 in location 4mem: storing 11 in location 1mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 11 in location 4");
  CHECK_TRACE_COUNT("mem", 8);
}
void test_tangle_tangles_into_all_labels_with_same_name_2() {
  Trace_file = "tangle_tangles_into_all_labels_with_same_name_2";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  <label1>\n  4:number <- copy 10\n]\nbefore <label1> [\n  2:number <- copy 12\n]\nafter <label1> [\n  3:number <- copy 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 10 in location 4");
  CHECK_TRACE_COUNT("mem", 6);
}
void test_tangle_tangles_into_all_labels_with_same_name_3() {
  Trace_file = "tangle_tangles_into_all_labels_with_same_name_3";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  <foo>\n  4:number <- copy 10\n]\nbefore <label1> [\n  2:number <- copy 12\n]\nafter <label1> [\n  3:number <- copy 12\n]\nafter <foo> [\n  <label1>\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 12 in location 2mem: storing 12 in location 3mem: storing 10 in location 4");
  CHECK_TRACE_COUNT("mem", 6);
}
void test_tangle_handles_jump_target_inside_fragment() {
  Trace_file = "tangle_handles_jump_target_inside_fragment";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  4:number <- copy 10\n]\nbefore <label1> [\n  jump +label2:label\n  2:number <- copy 12\n  +label2\n  3:number <- copy 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 12 in location 3mem: storing 10 in location 4");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 12 in label 2");
  CHECK_TRACE_COUNT("mem", 3);
}
void test_tangle_renames_jump_target() {
  Trace_file = "tangle_renames_jump_target";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  +label2\n  4:number <- copy 10\n]\nbefore <label1> [\n  jump +label2:label\n  2:number <- copy 12\n  +label2  # renamed\n  3:number <- copy 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 12 in location 3mem: storing 10 in location 4");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 12 in label 2");
  CHECK_TRACE_COUNT("mem", 3);
}
void test_tangle_jump_to_base_recipe() {
  Trace_file = "tangle_jump_to_base_recipe";
  run("recipe main [\n  1:number <- copy 10\n  <label1>\n  +label2\n  4:number <- copy 10\n]\nbefore <label1> [\n  jump +label2:label\n  2:number <- copy 12\n  3:number <- copy 12\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 10 in location 1mem: storing 10 in location 4");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 12 in label 2");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 12 in location 3");
  CHECK_TRACE_COUNT("mem", 2);
}

void rewrite_stashes_to_text(recipe_ordinal r) {
  recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- rewrite 'stash' instructions in recipe " << caller.name << end();
  if (contains_named_locations(caller))
    rewrite_stashes_to_text_named(caller);
  // in recipes without named locations, 'stash' is still not extensible
}

bool contains_named_locations(const recipe& caller) {
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    const instruction& inst = caller.steps.at(i);
    for (long long int in = 0; in < SIZE(inst.ingredients); ++in)
      if (is_named_location(inst.ingredients.at(in)))
        return true;
    for (long long int out = 0; out < SIZE(inst.products); ++out)
      if (is_named_location(inst.products.at(out)))
        return true;
  }
  return false;
}

void rewrite_stashes_to_text_named(recipe& caller) {
  static long long int stash_instruction_idx = 0;
  vector<instruction> new_instructions;
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    instruction& inst = caller.steps.at(i);
    if (inst.name == "stash") {
      for (long long int j = 0; j < SIZE(inst.ingredients); ++j) {
        if (is_literal(inst.ingredients.at(j))) continue;
        if (is_mu_string(inst.ingredients.at(j))) continue;
        instruction def;
        def.name = "to-text-line";
        def.ingredients.push_back(inst.ingredients.at(j));
        ostringstream ingredient_name;
        ingredient_name << "stash_" << stash_instruction_idx << '_' << j << ":address:shared:array:character";
        def.products.push_back(reagent(ingredient_name.str()));
        new_instructions.push_back(def);
        inst.ingredients.at(j).clear();  // reclaim old memory
        inst.ingredients.at(j) = reagent(ingredient_name.str());
      }
    }
    new_instructions.push_back(inst);
  }
  new_instructions.swap(caller.steps);
}


void test_dilated_reagent() {
  Trace_file = "dilated_reagent";
  load("recipe main [\n  {1: number, foo: bar} <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("parse:   product: 1: \"number\", {\"foo\": \"bar\"}");
}
void test_load_trailing_space_after_curly_bracket() {
  Trace_file = "load_trailing_space_after_curly_bracket";
  load("recipe main [\n  # line below has a space at the end\n  { \n]\n# successfully parsed\n");
}
void test_dilated_reagent_with_comment() {
  Trace_file = "dilated_reagent_with_comment";
  Hide_errors = true;
  run("recipe main [\n  {1: number, foo: bar} <- copy 34  # test comment\n]\n");
  CHECK_TRACE_CONTENTS("parse:   product: 1: \"number\", {\"foo\": \"bar\"}");
  CHECK_TRACE_COUNT("error", 0);
}
void test_dilated_reagent_with_comment_immediately_following() {
  Trace_file = "dilated_reagent_with_comment_immediately_following";
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy {34: literal}  # test comment\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
// A curly is considered a label if it's the last thing on a line. Dilated
// reagents should remain all on one line.
bool start_of_dilated_reagent(istream& in) {
  if (in.peek() != '{') return false;
  long long int pos = in.tellg();
  in.get();  // slurp '{'
  skip_whitespace_but_not_newline(in);
  char next = in.peek();
  in.seekg(pos);
  return next != '\n';
}

// Assume the first letter is an open bracket, and read everything until the
// matching close bracket.
// We balance {} () and []. And we skip one character after '\'.
string slurp_balanced_bracket(istream& in) {
  ostringstream result;
  char c;
  list<char> open_brackets;
  while (in >> c) {
    if (c == '\\') {
      // always silently skip the next character
      result << c;
      if (!(in >> c)) break;
      result << c;
      continue;
    }
    if (c == '(') open_brackets.push_back(c);
    if (c == ')') {
      assert(open_brackets.back() == '(');
      open_brackets.pop_back();
    }
    if (c == '[') open_brackets.push_back(c);
    if (c == ']') {
      assert(open_brackets.back() == '[');
      open_brackets.pop_back();
    }
    if (c == '{') open_brackets.push_back(c);
    if (c == '}') {
      assert(open_brackets.back() == '{');
      open_brackets.pop_back();
    }
    result << c;
    if (open_brackets.empty()) break;
  }
  skip_whitespace_and_comments_but_not_newline(in);
  return result.str();
}

string slurp_key(istream& in) {
  string result = next_word(in);
  while (!result.empty() && *result.rbegin() == ':')
    strip_last(result);
  while (isspace(in.peek()) || in.peek() == ':')
    in.get();
  return result;
}

// So far instructions can only contain linear lists of properties. Now we add
// support for more complex trees of properties in dilated reagents. This will
// come in handy later for expressing complex types, like "a dictionary from
// (address to array of charaters) to (list of numbers)".

void test_dilated_reagent_with_nested_brackets() {
  Trace_file = "dilated_reagent_with_nested_brackets";
  run("recipe main [\n  {1: number, foo: (bar (baz quux))} <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("parse:   product: 1: \"number\", {\"foo\": (\"bar\" (\"baz\" \"quux\"))}");
}
string_tree* parse_string_tree(string_tree* s) {
  assert(!s->left && !s->right);
  if (s->value.at(0) != '(') return s;
  string_tree* result = parse_string_tree(s->value);
  delete s;
  return result;
}

string_tree* parse_string_tree(const string& s) {
  istringstream in(s);
  in >> std::noskipws;
  return parse_string_tree(in);
}

string_tree* parse_string_tree(istream& in) {
  skip_whitespace_but_not_newline(in);
  if (!has_data(in)) return NULL;
  if (in.peek() == ')') {
    in.get();
    return NULL;
  }
  if (in.peek() != '(') {
    string_tree* result = new string_tree(next_word(in));
    return result;
  }
  in.get();  // skip '('
  string_tree* result = NULL;
  string_tree** curr = &result;
  while (in.peek() != ')') {
    assert(has_data(in));
    *curr = new string_tree("");
    skip_whitespace_but_not_newline(in);
    if (in.peek() == '(')
      (*curr)->left = parse_string_tree(in);
    else
      (*curr)->value = next_word(in);
    curr = &(*curr)->right;
  }
  in.get();  // skip ')'
  return result;
}

void test_dilated_reagent_with_type_tree() {
  Trace_file = "dilated_reagent_with_type_tree";
  Hide_errors = true;  // 'map' isn't defined yet
  run("recipe main [\n  {1: (foo (address array character) (bar number))} <- copy 34\n]\n# just to avoid errors\ncontainer foo [\n]\ncontainer bar [\n]\n");
  CHECK_TRACE_CONTENTS("parse:   product: 1: (\"foo\" (\"address\" \"array\" \"character\") (\"bar\" \"number\"))");
}
void test_dilated_reagent_with_new() {
  Trace_file = "dilated_reagent_with_new";
  run("recipe main [\n  x:address:shared:address:number <- new {(address number): type}\n]\n");
  CHECK_TRACE_CONTENTS("new: size of (\"address\" \"number\") is 1");
}

void test_recipe_with_header() {
  Trace_file = "recipe_with_header";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z:number <- add x, y\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 8 in location 1");
}
void load_recipe_header(istream& in, recipe& result) {
  result.has_header = true;
  while (has_data(in) && in.peek() != '[' && in.peek() != '\n') {
    string s = next_word(in);
    if (s == "->") break;
    result.ingredients.push_back(reagent(s));
    trace(9999, "parse") << "header ingredient: " << result.ingredients.back().original_string << end();
    skip_whitespace_but_not_newline(in);
  }
  while (has_data(in) && in.peek() != '[' && in.peek() != '\n') {
    string s = next_word(in);
    result.products.push_back(reagent(s));
    trace(9999, "parse") << "header product: " << result.products.back().original_string << end();
    skip_whitespace_but_not_newline(in);
  }
  // there can only ever be one variant for main
  if (result.name != "main" && contains_key(Recipe_ordinal, result.name)) {
    const recipe_ordinal r = get(Recipe_ordinal, result.name);
  //?   cerr << result.name << ": " << contains_key(Recipe, r) << (contains_key(Recipe, r) ? get(Recipe, r).has_header : 0) << matching_variant_name(result) << '\n';
    if (!contains_key(Recipe, r) || get(Recipe, r).has_header) {
      string new_name = matching_variant_name(result);
      if (new_name.empty()) {
        // variant doesn't already exist
        new_name = next_unused_recipe_name(result.name);
        put(Recipe_ordinal, new_name, Next_recipe_ordinal++);
        get_or_insert(Recipe_variants, result.name).push_back(get(Recipe_ordinal, new_name));
      }
      trace(9999, "load") << "switching " << result.name << " to " << new_name << end();
      result.name = new_name;
  //?     cerr << "=> " << new_name << '\n';
    }
  }
  else {
    // save first variant
    put(Recipe_ordinal, result.name, Next_recipe_ordinal++);
    get_or_insert(Recipe_variants, result.name).push_back(get(Recipe_ordinal, result.name));
  }

  // End Load Recipe Header(result)
}

void test_recipe_handles_stray_comma() {
  Trace_file = "recipe_handles_stray_comma";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number, [\n  local-scope\n  load-ingredients\n  z:number <- add x, y\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 8 in location 1");
}
void test_recipe_handles_stray_comma_2() {
  Trace_file = "recipe_handles_stray_comma_2";
  run("recipe main [\n  foo\n]\nrecipe foo, [\n  1:number/raw <- add 2, 2\n]\nrecipe bar [\n  1:number/raw <- add 2, 3\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_recipe_handles_missing_bracket() {
  Trace_file = "recipe_handles_missing_bracket";
  Hide_errors = true;
  run("recipe main\n]\n");
  CHECK_TRACE_CONTENTS("error: recipe body must begin with '['");
}
void test_recipe_handles_missing_bracket_2() {
  Trace_file = "recipe_handles_missing_bracket_2";
  Hide_errors = true;
  run("recipe main\n  local-scope\n  {\n  }\n]\n# doesn't overflow line when reading header\n");
  CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope");
  run("");
  CHECK_TRACE_CONTENTS("error: recipe body must begin with '['");
}
void test_recipe_handles_missing_bracket_3() {
  Trace_file = "recipe_handles_missing_bracket_3";
  Hide_errors = true;
  run("recipe main  # comment\n  local-scope\n  {\n  }\n]\n# doesn't overflow line when reading header\n");
  CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope");
  run("");
  CHECK_TRACE_CONTENTS("error: recipe body must begin with '['");
}
void test_recipe_without_ingredients_or_products_has_header() {
  Trace_file = "recipe_without_ingredients_or_products_has_header";
  run("recipe test [\n  1:number <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("parse: recipe test has a header");
}
void test_show_clear_error_on_bad_call() {
  Trace_file = "show_clear_error_on_bad_call";
  Hide_errors = true;
  run("recipe main [\n  1:number <- foo 34\n]\nrecipe foo x:boolean -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("error: main: ingredient 0 has the wrong type at '1:number <- foo 34'");
}
void test_show_clear_error_on_bad_call_2() {
  Trace_file = "show_clear_error_on_bad_call_2";
  Hide_errors = true;
  run("recipe main [\n  1:boolean <- foo 34\n]\nrecipe foo x:number -> y:number [\n  local-scope\n  load-ingredients\n  reply x\n]\n");
  CHECK_TRACE_CONTENTS("error: main: product 0 has the wrong type at '1:boolean <- foo 34'");
}
void check_calls_against_header(const recipe_ordinal r) {
  trace(9991, "transform") << "--- type-check calls inside recipe " << get(Recipe, r).name << end();
  const recipe& caller = get(Recipe, r);
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    const instruction& inst = caller.steps.at(i);
    if (inst.operation < MAX_PRIMITIVE_RECIPES) continue;
    const recipe& callee = get(Recipe, inst.operation);
    if (!callee.has_header) continue;
    for (long int i = 0; i < min(SIZE(inst.ingredients), SIZE(callee.ingredients)); ++i) {
      // ingredients coerced from call to callee
      if (!types_coercible(callee.ingredients.at(i), inst.ingredients.at(i)))
        raise_error << maybe(caller.name) << "ingredient " << i << " has the wrong type at '" << to_string(inst) << "'\n" << end();
      if (is_unique_address(inst.ingredients.at(i)))
        raise << maybe(caller.name) << "try to avoid passing non-shared addresses into calls, like ingredient " << i << " at '" << to_string(inst) << "'\n" << end();
    }
    for (long int i = 0; i < min(SIZE(inst.products), SIZE(callee.products)); ++i) {
      if (is_dummy(inst.products.at(i))) continue;
      // products coerced from callee to call
      if (!types_coercible(inst.products.at(i), callee.products.at(i)))
        raise_error << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_string(inst) << "'\n" << end();
      if (is_unique_address(inst.products.at(i)))
        raise << maybe(caller.name) << "try to avoid getting non-shared addresses out of calls, like product " << i << " at '" << to_string(inst) << "'\n" << end();
    }
  }
}

bool is_unique_address(reagent x) {
  if (!canonize_type(x)) return false;
  if (!x.type) return false;
  if (x.type->value != get(Type_ordinal, "address")) return false;
  if (!x.type->right) return true;
  return x.type->right->value != get(Type_ordinal, "shared");
}


void test_warn_on_calls_with_addresses() {
  Trace_file = "warn_on_calls_with_addresses";
  Hide_warnings= true;
  run("recipe main [\n  1:address:number <- copy 3/unsafe\n  foo 1:address:number\n]\nrecipe foo x:address:number [\n  local-scope\n  load-ingredients\n]\n");
  CHECK_TRACE_CONTENTS("warn: main: try to avoid passing non-shared addresses into calls, like ingredient 0 at 'foo 1:address:number'");
}
void test_warn_on_calls_with_addresses_2() {
  Trace_file = "warn_on_calls_with_addresses_2";
  Hide_warnings= true;
  run("recipe main [\n  1:address:number <- foo\n]\nrecipe foo -> x:address:number [\n  local-scope\n  load-ingredients\n  x <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("warn: main: try to avoid getting non-shared addresses out of calls, like product 0 at '1:address:number <- foo '");
}
void test_recipe_headers_are_checked() {
  Trace_file = "recipe_headers_are_checked";
  Hide_errors = true;
  transform("recipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z:address:number <- copy 0/unsafe\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("error: add2: replied with the wrong type at 'reply z'");
}
void check_reply_instructions_against_header(const recipe_ordinal r) {
  const recipe& caller_recipe = get(Recipe, r);
  if (!caller_recipe.has_header) return;
  trace(9991, "transform") << "--- checking reply instructions against header for " << caller_recipe.name << end();
  for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) {
    const instruction& inst = caller_recipe.steps.at(i);
    if (inst.name != "reply") continue;
    if (SIZE(caller_recipe.products) != SIZE(inst.ingredients)) {
      raise_error << maybe(caller_recipe.name) << "replied with the wrong number of products at '" << to_string(inst) << "'\n" << end();
      continue;
    }
    for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) {
      if (!types_match(caller_recipe.products.at(i), inst.ingredients.at(i)))
        raise_error << maybe(caller_recipe.name) << "replied with the wrong type at '" << to_string(inst) << "'\n" << end();
    }
  }
}

void test_recipe_headers_are_checked_2() {
  Trace_file = "recipe_headers_are_checked_2";
  Hide_errors = true;
  transform("recipe add2 x:number, y:number [\n  local-scope\n  load-ingredients\n  z:address:number <- copy 0/unsafe\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("error: add2: replied with the wrong number of products at 'reply z'");
}
void test_recipe_headers_check_for_duplicate_names() {
  Trace_file = "recipe_headers_check_for_duplicate_names";
  Hide_errors = true;
  transform("recipe add2 x:number, x:number -> z:number [\n  local-scope\n  load-ingredients\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("error: add2: x can't repeat in the ingredients");
}
void check_header_ingredients(const recipe_ordinal r) {
  recipe& caller_recipe = get(Recipe, r);
  if (caller_recipe.products.empty()) return;
  caller_recipe.ingredient_index.clear();
  trace(9991, "transform") << "--- checking reply instructions against header for " << caller_recipe.name << end();
  for (long long int i = 0; i < SIZE(caller_recipe.ingredients); ++i) {
    if (contains_key(caller_recipe.ingredient_index, caller_recipe.ingredients.at(i).name))
      raise_error << maybe(caller_recipe.name) << caller_recipe.ingredients.at(i).name << " can't repeat in the ingredients\n" << end();
    put(caller_recipe.ingredient_index, caller_recipe.ingredients.at(i).name, i);
  }
}


void test_deduce_instruction_types_from_recipe_header() {
  Trace_file = "deduce_instruction_types_from_recipe_header";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z <- add x, y  # no type for z\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 8 in location 1");
}
void deduce_types_from_header(const recipe_ordinal r) {
  recipe& caller_recipe = get(Recipe, r);
  if (caller_recipe.products.empty()) return;
  trace(9991, "transform") << "--- deduce types from header for " << caller_recipe.name << end();
  map<string, const type_tree*> header_type;
  for (long long int i = 0; i < SIZE(caller_recipe.ingredients); ++i) {
    put(header_type, caller_recipe.ingredients.at(i).name, caller_recipe.ingredients.at(i).type);
    //TODO: replace to_string with names_to_string
    trace(9993, "transform") << "type of " << caller_recipe.ingredients.at(i).name << " is " << to_string(caller_recipe.ingredients.at(i).type) << end();
  }
  for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) {
    put(header_type, caller_recipe.products.at(i).name, caller_recipe.products.at(i).type);
    trace(9993, "transform") << "type of " << caller_recipe.products.at(i).name << " is " << to_string(caller_recipe.products.at(i).type) << end();
  }
  for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) {
    instruction& inst = caller_recipe.steps.at(i);
    trace(9992, "transform") << "instruction: " << to_string(inst) << end();
    for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
      if (inst.ingredients.at(i).type) continue;
      if (header_type.find(inst.ingredients.at(i).name) == header_type.end())
        continue;
      if (!inst.ingredients.at(i).type)
        inst.ingredients.at(i).type = new type_tree(*get(header_type, inst.ingredients.at(i).name));
      trace(9993, "transform") << "type of " << inst.ingredients.at(i).name << " is " << to_string(inst.ingredients.at(i).type) << end();
    }
    for (long long int i = 0; i < SIZE(inst.products); ++i) {
      trace(9993, "transform") << "  product: " << to_string(inst.products.at(i)) << end();
      if (inst.products.at(i).type) continue;
      if (header_type.find(inst.products.at(i).name) == header_type.end())
        continue;
      if (!inst.products.at(i).type)
        inst.products.at(i).type = new type_tree(*get(header_type, inst.products.at(i).name));
      trace(9993, "transform") << "type of " << inst.products.at(i).name << " is " << to_string(inst.products.at(i).type) << end();
    }
  }
}


void test_reply_based_on_header() {
  Trace_file = "reply_based_on_header";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z <- add x, y\n  reply\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 8 in location 1");
}
void fill_in_reply_ingredients(recipe_ordinal r) {
  recipe& caller_recipe = get(Recipe, r);
  if (!caller_recipe.has_header) return;
  trace(9991, "transform") << "--- fill in reply ingredients from header for recipe " << caller_recipe.name << end();
  for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) {
    instruction& inst = caller_recipe.steps.at(i);
    if (inst.name == "reply")
      add_header_products(inst, caller_recipe);
  }
  // fall through reply
  if (caller_recipe.steps.at(SIZE(caller_recipe.steps)-1).name != "reply") {
    instruction inst;
    inst.name = "reply";
    add_header_products(inst, caller_recipe);
    caller_recipe.steps.push_back(inst);
  }
}

void add_header_products(instruction& inst, const recipe& caller_recipe) {
  assert(inst.name == "reply");
  // collect any products with the same names as ingredients
  for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) {
    // if the ingredient is missing, add it from the header
    if (SIZE(inst.ingredients) == i)
      inst.ingredients.push_back(caller_recipe.products.at(i));
    // if it's missing /same_as_ingredient, try to fill it in
    if (contains_key(caller_recipe.ingredient_index, caller_recipe.products.at(i).name) && !has_property(inst.ingredients.at(i), "same_as_ingredient")) {
      ostringstream same_as_ingredient;
      same_as_ingredient << get(caller_recipe.ingredient_index, caller_recipe.products.at(i).name);
      inst.ingredients.at(i).properties.push_back(pair<string, string_tree*>("same-as-ingredient", new string_tree(same_as_ingredient.str())));
    }
  }
}

void test_explicit_reply_ignores_header() {
  Trace_file = "explicit_reply_ignores_header";
  run("recipe main [\n  1:number/raw, 2:number/raw <- add2 3, 5\n]\nrecipe add2 a:number, b:number -> y:number, z:number [\n  local-scope\n  load-ingredients\n  y <- add a, b\n  z <- subtract a, b\n  reply a, z\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 3 in location 1mem: storing -2 in location 2");
}
void test_reply_on_fallthrough_based_on_header() {
  Trace_file = "reply_on_fallthrough_based_on_header";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z <- add x, y\n]\n");
  CHECK_TRACE_CONTENTS("transform: instruction: reply z:numbermem: storing 8 in location 1");
}
void test_reply_on_fallthrough_already_exists() {
  Trace_file = "reply_on_fallthrough_already_exists";
  run("recipe main [\n  1:number/raw <- add2 3, 5\n]\nrecipe add2 x:number, y:number -> z:number [\n  local-scope\n  load-ingredients\n  z <- add x, y  # no type for z\n  reply z\n]\n");
  CHECK_TRACE_CONTENTS("transform: instruction: reply z");
  CHECK_TRACE_DOESNT_CONTAIN("transform: instruction: reply z:number");
  run("");
  CHECK_TRACE_CONTENTS("mem: storing 8 in location 1");
}
void test_recipe_headers_perform_same_ingredient_check() {
  Trace_file = "recipe_headers_perform_same_ingredient_check";
  Hide_errors = true;
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 34\n  3:number <- add2 1:number, 2:number\n]\nrecipe add2 x:number, y:number -> x:number [\n  local-scope\n  load-ingredients\n]\n");
  CHECK_TRACE_CONTENTS("error: main: '3:number <- add2 1:number, 2:number' should write to 1:number rather than 3:number");
}

void test_static_dispatch() {
  Trace_file = "static_dispatch";
  run("recipe main [\n  7:number/raw <- test 3\n]\nrecipe test a:number -> z:number [\n  z <- copy 1\n]\nrecipe test a:number, b:number -> z:number [\n  z <- copy 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 7");
}
string matching_variant_name(const recipe& rr) {
  const vector<recipe_ordinal>& variants = get_or_insert(Recipe_variants, rr.name);
  for (long long int i = 0; i < SIZE(variants); ++i) {
    if (!contains_key(Recipe, variants.at(i))) continue;
    const recipe& candidate = get(Recipe, variants.at(i));
    if (!all_reagents_match(rr, candidate)) continue;
    return candidate.name;
  }
  return "";
}

bool all_reagents_match(const recipe& r1, const recipe& r2) {
  if (SIZE(r1.ingredients) != SIZE(r2.ingredients)) return false;
  if (SIZE(r1.products) != SIZE(r2.products)) return false;
  for (long long int i = 0; i < SIZE(r1.ingredients); ++i) {
    if (!deeply_equal_type_names(r1.ingredients.at(i), r2.ingredients.at(i))) {
      return false;
    }
  }
  for (long long int i = 0; i < SIZE(r1.products); ++i) {
    if (!deeply_equal_type_names(r1.products.at(i), r2.products.at(i))) {
      return false;
    }
  }
  return true;
}

bool deeply_equal_type_names(const reagent& a, const reagent& b) {
  return deeply_equal_type_names(a.type, b.type);
}
bool deeply_equal_type_names(const type_tree* a, const type_tree* b) {
  if (!a) return !b;
  if (!b) return !a;
  if (a->name == "literal" && b->name == "literal")
    return true;
  if (a->name == "literal")
    return Literal_type_names.find(b->name) != Literal_type_names.end();
  if (b->name == "literal")
    return Literal_type_names.find(a->name) != Literal_type_names.end();
  return a->name == b->name
      && deeply_equal_type_names(a->left, b->left)
      && deeply_equal_type_names(a->right, b->right);
}

string next_unused_recipe_name(const string& recipe_name) {
  for (long long int i = 2; ; ++i) {
    ostringstream out;
    out << recipe_name << '_' << i;
    if (!contains_key(Recipe_ordinal, out.str()))
      return out.str();
  }
}


void test_static_dispatch_picks_most_similar_variant() {
  Trace_file = "static_dispatch_picks_most_similar_variant";
  run("recipe main [\n  7:number/raw <- test 3, 4, 5\n]\nrecipe test a:number -> z:number [\n  z <- copy 1\n]\nrecipe test a:number, b:number -> z:number [\n  z <- copy 2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 7");
}
void resolve_ambiguous_calls(recipe_ordinal r) {
  cerr << "DDD " << get(Recipe, r).name << ": " << contains_key(Type_ordinal, "_elem") << '\n';
  recipe& caller_recipe = get(Recipe, r);
  trace(9991, "transform") << "--- resolve ambiguous calls for recipe " << caller_recipe.name << end();
  for (long long int index = 0; index < SIZE(caller_recipe.steps); ++index) {
    instruction& inst = caller_recipe.steps.at(index);
    if (inst.is_label) continue;
    if (non_ghost_size(get_or_insert(Recipe_variants, inst.name)) == 0) continue;
    trace(9992, "transform") << "instruction " << inst.original_string << end();
    resolve_stack.push_front(call(r));
    resolve_stack.front().running_step_index = index;
    cerr << "EEE " << contains_key(Type_ordinal, "_elem") << '\n';
    string new_name = best_variant(inst, caller_recipe);
    if (!new_name.empty())
      inst.name = new_name;
    assert(resolve_stack.front().running_recipe == r);
    assert(resolve_stack.front().running_step_index == index);
    resolve_stack.pop_front();
  }
  if (contains_key(Type_ordinal, "_elem")) {
    cerr << "ZZZ " << get(Recipe, r).name << '\n';
    exit(0);
  }
}

string best_variant(instruction& inst, const recipe& caller_recipe) {
  cerr << "FFF " << contains_key(Type_ordinal, "_elem") << '\n';
  vector<recipe_ordinal>& variants = get(Recipe_variants, inst.name);
  vector<recipe_ordinal> candidates;

  // Static Dispatch Phase 1
  candidates = strictly_matching_variants(inst, variants);
  if (!candidates.empty()) return best_variant(inst, candidates).name;

  // Static Dispatch Phase 2 (shape-shifting recipes in a later layer)
  candidates = strictly_matching_shape_shifting_variants(inst, variants);
  if (!candidates.empty()) {
    recipe_ordinal exemplar = best_shape_shifting_variant(inst, candidates);
    trace(9992, "transform") << "found variant to specialize: " << exemplar << ' ' << get(Recipe, exemplar).name << end();
    cerr << "GGG " << contains_key(Type_ordinal, "_elem") << '\n';
    recipe_ordinal new_recipe_ordinal = new_variant(exemplar, inst, caller_recipe);
    cerr << "XXX " << contains_key(Type_ordinal, "_elem") << '\n';
    if (new_recipe_ordinal == 0) goto skip_shape_shifting_variants;
    variants.push_back(new_recipe_ordinal);  // side-effect
    recipe& variant = get(Recipe, new_recipe_ordinal);
    // perform all transforms on the new specialization
    cerr << "YYY " << contains_key(Type_ordinal, "_elem") << '\n';
    if (!variant.steps.empty()) {
      trace(9992, "transform") << "transforming new specialization: " << variant.name << end();
      for (long long int t = 0; t < SIZE(Transform); ++t) {
        (*Transform.at(t))(new_recipe_ordinal);
      }
    }
    variant.transformed_until = SIZE(Transform)-1;
    trace(9992, "transform") << "new specialization: " << variant.name << end();
    return variant.name;
  }
  skip_shape_shifting_variants:;


  // End Static Dispatch Phase 2

  // Static Dispatch Phase 3
  candidates = strictly_matching_variants_except_literal_against_boolean(inst, variants);
  if (!candidates.empty()) return best_variant(inst, candidates).name;

  // Static Dispatch Phase 4
  candidates = matching_variants(inst, variants);
  if (!candidates.empty()) return best_variant(inst, candidates).name;

  // error messages
  if (get(Recipe_ordinal, inst.name) >= MAX_PRIMITIVE_RECIPES) {  // we currently don't check types for primitive variants
    raise_error << maybe(caller_recipe.name) << "failed to find a matching call for '" << to_string(inst) << "'\n" << end();
    for (list<call>::iterator p = /*skip*/++resolve_stack.begin(); p != resolve_stack.end(); ++p) {
      const recipe& specializer_recipe = get(Recipe, p->running_recipe);
      const instruction& specializer_inst = specializer_recipe.steps.at(p->running_step_index);
      if (specializer_recipe.name != "interactive")
        raise_error << "  (from '" << to_string(specializer_inst) << "' in " << specializer_recipe.name << ")\n" << end();
      else
        raise_error << "  (from '" << to_string(specializer_inst) << "')\n" << end();
      // One special-case to help with the rewrite_stash transform. (cross-layer)
      if (specializer_inst.products.at(0).name.find("stash_") == 0) {
        instruction stash_inst;
        if (next_stash(*p, &stash_inst)) {
          if (specializer_recipe.name != "interactive")
            raise_error << "  (part of '" << stash_inst.original_string << "' in " << specializer_recipe.name << ")\n" << end();
          else
            raise_error << "  (part of '" << stash_inst.original_string << "')\n" << end();
        }
      }
    }
  }
  return "";
}

// phase 1
vector<recipe_ordinal> strictly_matching_variants(const instruction& inst, vector<recipe_ordinal>& variants) {
  vector<recipe_ordinal> result;
  for (long long int i = 0; i < SIZE(variants); ++i) {
    if (variants.at(i) == -1) continue;
    trace(9992, "transform") << "checking variant (strict) " << i << ": " << header_label(variants.at(i)) << end();
    if (all_header_reagents_strictly_match(inst, get(Recipe, variants.at(i))))
      result.push_back(variants.at(i));
  }
  return result;
}

bool all_header_reagents_strictly_match(const instruction& inst, const recipe& variant) {
  for (long long int i = 0; i < min(SIZE(inst.ingredients), SIZE(variant.ingredients)); ++i) {
    if (!types_strictly_match(variant.ingredients.at(i), inst.ingredients.at(i))) {
      trace(9993, "transform") << "strict match failed: ingredient " << i << end();
      return false;
    }
  }
  for (long long int i = 0; i < min(SIZE(inst.products), SIZE(variant.products)); ++i) {
    if (is_dummy(inst.products.at(i))) continue;
    if (!types_strictly_match(variant.products.at(i), inst.products.at(i))) {
      trace(9993, "transform") << "strict match failed: product " << i << end();
      return false;
    }
  }
  return true;
}

// phase 3
vector<recipe_ordinal> strictly_matching_variants_except_literal_against_boolean(const instruction& inst, vector<recipe_ordinal>& variants) {
  vector<recipe_ordinal> result;
  for (long long int i = 0; i < SIZE(variants); ++i) {
    if (variants.at(i) == -1) continue;
    trace(9992, "transform") << "checking variant (strict except literals-against-booleans) " << i << ": " << header_label(variants.at(i)) << end();
    if (all_header_reagents_strictly_match_except_literal_against_boolean(inst, get(Recipe, variants.at(i))))
      result.push_back(variants.at(i));
  }
  return result;
}

bool all_header_reagents_strictly_match_except_literal_against_boolean(const instruction& inst, const recipe& variant) {
  for (long long int i = 0; i < min(SIZE(inst.ingredients), SIZE(variant.ingredients)); ++i) {
    if (!types_strictly_match_except_literal_against_boolean(variant.ingredients.at(i), inst.ingredients.at(i))) {
      trace(9993, "transform") << "strict match failed: ingredient " << i << end();
      return false;
    }
  }
  for (long long int i = 0; i < min(SIZE(variant.products), SIZE(inst.products)); ++i) {
    if (is_dummy(inst.products.at(i))) continue;
    if (!types_strictly_match_except_literal_against_boolean(variant.products.at(i), inst.products.at(i))) {
      trace(9993, "transform") << "strict match failed: product " << i << end();
      return false;
    }
  }
  return true;
}

// phase 4
vector<recipe_ordinal> matching_variants(const instruction& inst, vector<recipe_ordinal>& variants) {
  vector<recipe_ordinal> result;
  for (long long int i = 0; i < SIZE(variants); ++i) {
    if (variants.at(i) == -1) continue;
    trace(9992, "transform") << "checking variant " << i << ": " << header_label(variants.at(i)) << end();
    if (all_header_reagents_match(inst, get(Recipe, variants.at(i))))
      result.push_back(variants.at(i));
  }
  return result;
}

bool all_header_reagents_match(const instruction& inst, const recipe& variant) {
  for (long long int i = 0; i < min(SIZE(inst.ingredients), SIZE(variant.ingredients)); ++i) {
    if (!types_match(variant.ingredients.at(i), inst.ingredients.at(i))) {
      trace(9993, "transform") << "strict match failed: ingredient " << i << end();
      return false;
    }
  }
  for (long long int i = 0; i < min(SIZE(variant.products), SIZE(inst.products)); ++i) {
    if (is_dummy(inst.products.at(i))) continue;
    if (!types_match(variant.products.at(i), inst.products.at(i))) {
      trace(9993, "transform") << "strict match failed: product " << i << end();
      return false;
    }
  }
  return true;
}

// tie-breaker for each phase
const recipe& best_variant(const instruction& inst, vector<recipe_ordinal>& candidates) {
  assert(!candidates.empty());
  long long int min_score = 999;
  long long int min_index = 0;
  for (long long int i = 0; i < SIZE(candidates); ++i) {
    const recipe& candidate = get(Recipe, candidates.at(i));
    long long int score = abs(SIZE(candidate.products)-SIZE(inst.products))
                          + abs(SIZE(candidate.ingredients)-SIZE(inst.ingredients));
    assert(score < 999);
    if (score < min_score) {
      min_score = score;
      min_index = i;
    }
  }
  return get(Recipe, candidates.at(min_index));
}

long long int non_ghost_size(vector<recipe_ordinal>& variants) {
  long long int result = 0;
  for (long long int i = 0; i < SIZE(variants); ++i)
    if (variants.at(i) != -1) ++result;
  return result;
}

bool next_stash(const call& c, instruction* stash_inst) {
  const recipe& specializer_recipe = get(Recipe, c.running_recipe);
  long long int index = c.running_step_index;
  for (++index; index < SIZE(specializer_recipe.steps); ++index) {
    const instruction& inst = specializer_recipe.steps.at(index);
    if (inst.name == "stash") {
      *stash_inst = inst;
      return true;
    }
  }
  return false;
}

void test_static_dispatch_disabled_in_recipe_without_variants() {
  Trace_file = "static_dispatch_disabled_in_recipe_without_variants";
  run("recipe main [\n  1:number <- test 3\n]\nrecipe test [\n  2:number <- next-ingredient  # ensure no header\n  reply 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}
void test_static_dispatch_disabled_on_headerless_definition() {
  Trace_file = "static_dispatch_disabled_on_headerless_definition";
  Hide_warnings = true;
  run("recipe test a:number -> z:number [\n  z <- copy 1\n]\nrecipe test [\n  reply 34\n]\n");
  CHECK_TRACE_CONTENTS("warn: redefining recipe test");
}
void test_static_dispatch_disabled_on_headerless_definition_2() {
  Trace_file = "static_dispatch_disabled_on_headerless_definition_2";
  Hide_warnings = true;
  run("recipe test [\n  reply 34\n]\nrecipe test a:number -> z:number [\n  z <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("warn: redefining recipe test");
}
void test_static_dispatch_on_primitive_names() {
  Trace_file = "static_dispatch_on_primitive_names";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- copy 34\n  3:boolean <- equal 1:number, 2:number\n  4:boolean <- copy 0/false\n  5:boolean <- copy 0/false\n  6:boolean <- equal 4:boolean, 5:boolean\n]\n# temporarily hardcode number equality to always fail\nrecipe equal x:number, y:number -> z:boolean [\n  local-scope\n  load-ingredients\n  z <- copy 0/false\n]\n# comparing numbers used overload\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3mem: storing 1 in location 6");
}
void test_static_dispatch_works_with_dummy_results_for_containers() {
  Trace_file = "static_dispatch_works_with_dummy_results_for_containers";
  Hide_errors = true;
  run("recipe main [\n  _ <- test 3, 4\n]\nrecipe test a:number -> z:point [\n  local-scope\n  load-ingredients\n  z <- merge a, 0\n]\nrecipe test a:number, b:number -> z:point [\n  local-scope\n  load-ingredients\n  z <- merge a, b\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_static_dispatch_works_with_compound_type_containing_container_defined_after_first_use() {
  Trace_file = "static_dispatch_works_with_compound_type_containing_container_defined_after_first_use";
  Hide_errors = true;
  run("recipe main [\n  x:address:shared:foo <- new foo:type\n  test x\n]\ncontainer foo [\n  x:number\n]\nrecipe test a:address:shared:foo -> z:number [\n  local-scope\n  load-ingredients\n  z:number <- get *a, x:offset\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_static_dispatch_works_with_compound_type_containing_container_defined_after_second_use() {
  Trace_file = "static_dispatch_works_with_compound_type_containing_container_defined_after_second_use";
  Hide_errors = true;
  run("recipe main [\n  x:address:shared:foo <- new foo:type\n  test x\n]\nrecipe test a:address:shared:foo -> z:number [\n  local-scope\n  load-ingredients\n  z:number <- get *a, x:offset\n]\ncontainer foo [\n  x:number\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_static_dispatch_prefers_literals_to_be_numbers_rather_than_addresses() {
  Trace_file = "static_dispatch_prefers_literals_to_be_numbers_rather_than_addresses";
  run("recipe main [\n  1:number <- foo 0\n]\nrecipe foo x:address:number -> y:number [\n  reply 34\n]\nrecipe foo x:number -> y:number [\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 1");
}
void test_static_dispatch_on_non_literal_character_ignores_variant_with_numbers() {
  Trace_file = "static_dispatch_on_non_literal_character_ignores_variant_with_numbers";
  Hide_errors = true;
  run("recipe main [\n  local-scope\n  x:character <- copy 10/newline\n  1:number/raw <- foo x\n]\nrecipe foo x:number -> y:number [\n  load-ingredients\n  reply 34\n]\n");
  CHECK_TRACE_CONTENTS("error: main: ingredient 0 has the wrong type at '1:number/raw <- foo x'");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 1");
}
void test_static_dispatch_dispatches_literal_to_boolean_before_character() {
  Trace_file = "static_dispatch_dispatches_literal_to_boolean_before_character";
  run("recipe main [\n  1:number/raw <- foo 0  # valid literal for boolean\n]\nrecipe foo x:character -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:boolean -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# boolean variant is preferred\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 1");
}
void test_static_dispatch_dispatches_literal_to_character_when_out_of_boolean_range() {
  Trace_file = "static_dispatch_dispatches_literal_to_character_when_out_of_boolean_range";
  run("recipe main [\n  1:number/raw <- foo 97  # not a valid literal for boolean\n]\nrecipe foo x:character -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:boolean -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# character variant is preferred\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}
void test_static_dispatch_dispatches_literal_to_number_if_at_all_possible() {
  Trace_file = "static_dispatch_dispatches_literal_to_number_if_at_all_possible";
  run("recipe main [\n  1:number/raw <- foo 97\n]\nrecipe foo x:character -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:number -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# number variant is preferred\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 1");
}
string header_label(recipe_ordinal r) {
  const recipe& caller = get(Recipe, r);
  ostringstream out;
  out << "recipe " << caller.name;
  for (long long int i = 0; i < SIZE(caller.ingredients); ++i)
    out << ' ' << to_string(caller.ingredients.at(i));
  if (!caller.products.empty()) out << " ->";
  for (long long int i = 0; i < SIZE(caller.products); ++i)
    out << ' ' << to_string(caller.products.at(i));
  return out.str();
}

void test_reload_variant_retains_other_variants() {
  Trace_file = "reload_variant_retains_other_variants";
  run("recipe main [\n  1:number <- copy 34\n  2:number <- foo 1:number\n]\nrecipe foo x:number -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:address:number -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\nrecipe! foo x:address:number -> y:number [\n  local-scope\n  load-ingredients\n  reply 36\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
  CHECK_TRACE_COUNT("error", 0);
  run("");
  CHECK_TRACE_COUNT("warn", 0);
}
void test_dispatch_errors_come_after_unknown_name_errors() {
  Trace_file = "dispatch_errors_come_after_unknown_name_errors";
  Hide_errors = true;
  run("recipe main [\n  y:number <- foo x\n]\nrecipe foo a:number -> b:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo a:boolean -> b:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("error: main: missing type for x in 'y:number <- foo x'error: main: failed to find a matching call for 'y:number <- foo x'");
}

void test_size_of_shape_shifting_container() {
  Trace_file = "size_of_shape_shifting_container";
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  1:foo:number <- merge 12, 13\n  3:foo:point <- merge 14, 15, 16\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 1mem: storing 13 in location 2mem: storing 14 in location 3mem: storing 15 in location 4mem: storing 16 in location 5");
}
void test_size_of_shape_shifting_container_2() {
  Trace_file = "size_of_shape_shifting_container_2";
  Hide_errors = true;
  run("# multiple type ingredients\ncontainer foo:_a:_b [\n  x:_a\n  y:_b\n]\nrecipe main [\n  1:foo:number:boolean <- merge 34, 1/true\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_size_of_shape_shifting_container_3() {
  Trace_file = "size_of_shape_shifting_container_3";
  Hide_errors = true;
  run("container foo:_a:_b [\n  x:_a\n  y:_b\n]\nrecipe main [\n  1:address:shared:array:character <- new [abc]\n  # compound types for type ingredients\n  {2: (foo number (address shared array character))} <- merge 34/x, 1:address:shared:array:character/y\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_size_of_shape_shifting_container_4() {
  Trace_file = "size_of_shape_shifting_container_4";
  Hide_errors = true;
  run("container foo:_a:_b [\n  x:_a\n  y:_b\n]\ncontainer bar:_a:_b [\n  # dilated element\n  {data: (foo _a (address shared _b))}\n]\nrecipe main [\n  1:address:shared:array:character <- new [abc]\n  2:bar:number:array:character <- merge 34/x, 1:address:shared:array:character/y\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void read_type_ingredients(string& name) {
  string save_name = name;
  istringstream in(save_name);
  name = slurp_until(in, ':');
  if (!contains_key(Type_ordinal, name) || get(Type_ordinal, name) == 0)
    put(Type_ordinal, name, Next_type_ordinal++);
  type_info& info = get_or_insert(Type, get(Type_ordinal, name));
  long long int next_type_ordinal = START_TYPE_INGREDIENTS;
  while (has_data(in)) {
    string curr = slurp_until(in, ':');
    if (info.type_ingredient_names.find(curr) != info.type_ingredient_names.end()) {
      raise_error << "can't repeat type ingredient names in a single container definition\n" << end();
      return;
    }
    put(info.type_ingredient_names, curr, next_type_ordinal++);
  }
}

bool is_type_ingredient_name(const string& type) {
  return !type.empty() && type.at(0) == '_';
}

void test_size_of_shape_shifting_exclusive_container() {
  Trace_file = "size_of_shape_shifting_exclusive_container";
  run("exclusive-container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  1:foo:number <- merge 0/x, 34\n  3:foo:point <- merge 0/x, 15, 16\n  6:foo:point <- merge 1/y, 23\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1mem: storing 34 in location 2mem: storing 0 in location 3mem: storing 15 in location 4mem: storing 16 in location 5mem: storing 1 in location 6mem: storing 23 in location 7");
  CHECK_TRACE_COUNT("mem", 7);
}
// shape-shifting version of size_of
long long int size_of_type_ingredient(const type_tree* element_template, const type_tree* rest_of_use) {
  type_tree* element_type = type_ingredient(element_template, rest_of_use);
  if (!element_type) return 0;
  long long int result = size_of(element_type);
  delete element_type;
  return result;
}

type_tree* type_ingredient(const type_tree* element_template, const type_tree* rest_of_use) {
  long long int type_ingredient_index = element_template->value - START_TYPE_INGREDIENTS;
  const type_tree* curr = rest_of_use;
  if (!curr) return NULL;
  while (type_ingredient_index > 0) {
    --type_ingredient_index;
    curr = curr->right;
    if (!curr) return NULL;
  }
  assert(curr);
  if (curr->left) curr = curr->left;
  assert(curr->value > 0);
  trace(9999, "type") << "type deduced to be " << get(Type, curr->value).name << "$" << end();
  return new type_tree(*curr);
}

void test_get_on_shape_shifting_container() {
  Trace_file = "get_on_shape_shifting_container";
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  1:foo:point <- merge 14, 15, 16\n  2:number <- get 1:foo:point, y:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 16 in location 2");
}
void test_get_on_shape_shifting_container_2() {
  Trace_file = "get_on_shape_shifting_container_2";
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  1:foo:point <- merge 14, 15, 16\n  2:point <- get 1:foo:point, x:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 2mem: storing 15 in location 3");
}
void test_get_on_shape_shifting_container_3() {
  Trace_file = "get_on_shape_shifting_container_3";
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  1:foo:address:point <- merge 34/unsafe, 48\n  2:address:point <- get 1:foo:address:point, x:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
}
void test_get_on_shape_shifting_container_inside_container() {
  Trace_file = "get_on_shape_shifting_container_inside_container";
  run("container foo:_t [\n  x:_t\n  y:number\n]\ncontainer bar [\n  x:foo:point\n  y:number\n]\nrecipe main [\n  1:bar <- merge 14, 15, 16, 17\n  2:number <- get 1:bar, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 17 in location 2");
}
void test_get_on_complex_shape_shifting_container() {
  Trace_file = "get_on_complex_shape_shifting_container";
  run("container foo:_a:_b [\n  x:_a\n  y:_b\n]\nrecipe main [\n  1:address:shared:array:character <- new [abc]\n  {2: (foo number (address shared array character))} <- merge 34/x, 1:address:shared:array:character/y\n  3:address:shared:array:character <- get {2: (foo number (address shared array character))}, y:offset\n  4:boolean <- equal 1:address:shared:array:character, 3:address:shared:array:character\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 4");
}
bool contains_type_ingredient(const reagent& x) {
  return contains_type_ingredient(x.type);
}

bool contains_type_ingredient(const type_tree* type) {
  if (!type) return false;
  if (type->value >= START_TYPE_INGREDIENTS) return true;
  return contains_type_ingredient(type->left) || contains_type_ingredient(type->right);
}

// todo: too complicated and likely incomplete; maybe avoid replacing in place? Maybe process element_type and element_type_name in separate functions?
void replace_type_ingredients(type_tree* element_type, const type_tree* callsite_type, const type_info& container_info) {
  if (!callsite_type) return;  // error but it's already been raised above
  if (!element_type) return;

  // A. recurse first to avoid nested replaces (which I can't reason about yet)
  replace_type_ingredients(element_type->left, callsite_type, container_info);
  replace_type_ingredients(element_type->right, callsite_type, container_info);
  if (element_type->value < START_TYPE_INGREDIENTS) return;

  const long long int type_ingredient_index = element_type->value-START_TYPE_INGREDIENTS;
  if (!has_nth_type(callsite_type, type_ingredient_index)) {
    raise_error << "illegal type " << names_to_string(callsite_type) << " seems to be missing a type ingredient or three\n" << end();
    return;
  }

  // B. replace the current location
  const type_tree* replacement = NULL;
  bool splice_right = true ;
  {
    const type_tree* curr = callsite_type;
    for (long long int i = 0; i < type_ingredient_index; ++i)
      curr = curr->right;
    if (curr && curr->left) {
      replacement = curr->left;
    }
    else {
      // We want foo:_t to be used like foo:number, which expands to {foo: number}
      // rather than {foo: (number)}
      // We'd also like to use it with multiple types: foo:address:number.
      replacement = curr;
      if (!final_type_ingredient(type_ingredient_index, container_info)) {
        splice_right = false;
      }
    }
  }
  element_type->name = replacement->name;
  element_type->value = replacement->value;
  assert(!element_type->left);  // since value is set
  element_type->left = replacement->left ? new type_tree(*replacement->left) : NULL;
  if (splice_right) {
    type_tree* old_right = element_type->right;
    element_type->right = replacement->right ? new type_tree(*replacement->right) : NULL;
    append(element_type->right, old_right);
  }
}

bool final_type_ingredient(long long int type_ingredient_index, const type_info& container_info) {
  for (map<string, type_ordinal>::const_iterator p = container_info.type_ingredient_names.begin();
       p != container_info.type_ingredient_names.end();
       ++p) {
    if (p->second > START_TYPE_INGREDIENTS+type_ingredient_index) return false;
  }
  return true;
}

void append(type_tree*& base, type_tree* extra) {
  if (!base) {
    base = extra;
    return;
  }
  type_tree* curr = base;
  while (curr->right) curr = curr->right;
  curr->right = extra;
}

void append(string_tree*& base, string_tree* extra) {
  if (!base) {
    base = extra;
    return;
  }
  string_tree* curr = base;
  while (curr->right) curr = curr->right;
  curr->right = extra;
}

void test_replace_type_ingredients_entire() {
  run("container foo:_elem [\n"
      "  x:_elem\n"
      "  y:number\n"
      "]\n");
  reagent callsite("x:foo:point");
  reagent element = element_type(callsite, 0);
  cerr << debug_string(element) << '\n';
//?   DUMP("");
  CHECK_EQ(element.name, "x");
  cerr << get(Type_ordinal, "point") << '\n';
  cerr << contains_key(Type, 23) << '\n';
  for (map<string, type_ordinal>::iterator p = Type_ordinal.begin(); p != Type_ordinal.end(); ++p)
    if (p->second == 23) cerr << p->first << '\n';
  CHECK_EQ(element.type->name, "point");
  CHECK(!element.type->right);
}

void test_replace_type_ingredients_tail() {
  exit(0);
  run("container foo:_elem [\n"
      "  x:_elem\n"
      "]\n"
      "container bar:_elem [\n"
      "  x:foo:_elem\n"
      "]\n");
  reagent callsite("x:bar:point");
  reagent element = element_type(callsite, 0);
  CHECK_EQ(element.name, "x");
  CHECK_EQ(element.type->name, "foo");
  CHECK_EQ(element.type->right->name, "point");
  CHECK(!element.type->right->right);
}

void test_replace_type_ingredients_head_tail_multiple() {
  run("container foo:_elem [\n"
      "  x:_elem\n"
      "]\n"
      "container bar:_elem [\n"
      "  x:foo:_elem\n"
      "]\n");
  reagent callsite("x:bar:address:shared:array:character");
  reagent element = element_type(callsite, 0);
  CHECK_EQ(element.name, "x");
  CHECK_EQ(element.type->name, "foo");
  CHECK_EQ(element.type->right->name, "address");
  CHECK_EQ(element.type->right->right->name, "shared");
  CHECK_EQ(element.type->right->right->right->name, "array");
  CHECK_EQ(element.type->right->right->right->right->name, "character");
  CHECK(!element.type->right->right->right->right->right);
}

void test_replace_type_ingredients_head_middle() {
  run("container foo:_elem [\n"
      "  x:_elem\n"
      "]\n"
      "container bar:_elem [\n"
      "  x:foo:_elem:number\n"
      "]\n");
  reagent callsite("x:bar:address");
  reagent element = element_type(callsite, 0);
  CHECK_EQ(element.name, "x");
  CHECK(element.type)
  CHECK_EQ(element.type->name, "foo");
  CHECK(element.type->right)
  CHECK_EQ(element.type->right->name, "address");
  CHECK(element.type->right->right)
  CHECK_EQ(element.type->right->right->name, "number");
  CHECK(!element.type->right->right->right);
}

void test_replace_last_type_ingredient_with_multiple() {
  run("container foo:_a:_b [\n"
      "  x:_a\n"
      "  y:_b\n"
      "]\n");
  reagent callsite("{f: (foo number (address shared array character))}");
  reagent element1 = element_type(callsite, 0);
  CHECK_EQ(element1.name, "x");
  CHECK_EQ(element1.type->name, "number");
  CHECK(!element1.type->right);
  reagent element2 = element_type(callsite, 1);
  CHECK_EQ(element2.name, "y");
  CHECK_EQ(element2.type->name, "address");
  CHECK_EQ(element2.type->right->name, "shared");
  CHECK_EQ(element2.type->right->right->name, "array");
  CHECK_EQ(element2.type->right->right->right->name, "character");
  CHECK(!element2.type->right->right->right->right);
}

void test_replace_middle_type_ingredient_with_multiple() {
  run("container foo:_a:_b:_c [\n"
      "  x:_a\n"
      "  y:_b\n"
      "  z:_c\n"
      "]\n");
  reagent callsite("{f: (foo number (address shared array character) boolean)}");
  reagent element1 = element_type(callsite, 0);
  CHECK_EQ(element1.name, "x");
  CHECK_EQ(element1.type->name, "number");
  CHECK(!element1.type->right);
  reagent element2 = element_type(callsite, 1);
  CHECK_EQ(element2.name, "y");
  CHECK_EQ(element2.type->name, "address");
  CHECK_EQ(element2.type->right->name, "shared");
  CHECK_EQ(element2.type->right->right->name, "array");
  CHECK_EQ(element2.type->right->right->right->name, "character");
  CHECK(!element2.type->right->right->right->right);
  reagent element3 = element_type(callsite, 2);
  CHECK_EQ(element3.name, "z");
  CHECK_EQ(element3.type->name, "boolean");
  CHECK(!element3.type->right);
}

bool has_nth_type(const type_tree* base, long long int n) {
  assert(n >= 0);
  if (base == NULL) return false;
  if (n == 0) return true;
  return has_nth_type(base->right, n-1);
}

void test_get_on_shape_shifting_container_error() {
  Trace_file = "get_on_shape_shifting_container_error";
  Hide_errors = true;
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  10:foo:point <- merge 14, 15, 16\n  1:number <- get 10:foo, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("error: illegal type \"foo\" seems to be missing a type ingredient or three");
}
void test_get_address_on_shape_shifting_container() {
  Trace_file = "get_address_on_shape_shifting_container";
  run("container foo:_t [\n  x:_t\n  y:number\n]\nrecipe main [\n  10:foo:point <- merge 14, 15, 16\n  1:address:number <- get-address 10:foo:point, 1:offset\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 1");
}
void test_merge_check_shape_shifting_container_containing_exclusive_container() {
  Trace_file = "merge_check_shape_shifting_container_containing_exclusive_container";
  Hide_errors = true;
  run("container foo:_elem [\n  x:number\n  y:_elem\n]\nexclusive-container bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo:bar <- merge 23, 1/y, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 23 in location 1mem: storing 1 in location 2mem: storing 34 in location 3");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_shape_shifting_container_containing_exclusive_container_2() {
  Trace_file = "merge_check_shape_shifting_container_containing_exclusive_container_2";
  Hide_errors = true;
  run("container foo:_elem [\n  x:number\n  y:_elem\n]\nexclusive-container bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo:bar <- merge 23, 1/y, 34, 35\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too many ingredients in '1:foo:bar <- merge 23, 1/y, 34, 35'");
}
void test_merge_check_shape_shifting_exclusive_container_containing_container() {
  Trace_file = "merge_check_shape_shifting_exclusive_container_containing_container";
  Hide_errors = true;
  run("exclusive-container foo:_elem [\n  x:number\n  y:_elem\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo:bar <- merge 1/y, 23, 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 1mem: storing 23 in location 2mem: storing 34 in location 3");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_shape_shifting_exclusive_container_containing_container_2() {
  Trace_file = "merge_check_shape_shifting_exclusive_container_containing_container_2";
  Hide_errors = true;
  run("exclusive-container foo:_elem [\n  x:number\n  y:_elem\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo:bar <- merge 0/x, 23\n]\n");
  CHECK_TRACE_COUNT("error", 0);
}
void test_merge_check_shape_shifting_exclusive_container_containing_container_3() {
  Trace_file = "merge_check_shape_shifting_exclusive_container_containing_container_3";
  Hide_errors = true;
  run("exclusive-container foo:_elem [\n  x:number\n  y:_elem\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo:bar <- merge 1/y, 23\n]\n");
  CHECK_TRACE_CONTENTS("error: main: too few ingredients in '1:foo:bar <- merge 1/y, 23'");
}

void test_shape_shifting_recipe() {
  Trace_file = "shape_shifting_recipe";
  run("recipe main [\n  10:point <- merge 14, 15\n  11:point <- foo 10:point\n]\n# non-matching variant\nrecipe foo a:number -> result:number [\n  local-scope\n  load-ingredients\n  result <- copy 34\n]\n# matching shape-shifting variant\nrecipe foo a:_t -> result:_t [\n  local-scope\n  load-ingredients\n  result <- copy a\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 11mem: storing 15 in location 12");
}
// phase 2 of static dispatch
vector<recipe_ordinal> strictly_matching_shape_shifting_variants(const instruction& inst, vector<recipe_ordinal>& variants) {
  vector<recipe_ordinal> result;
  for (long long int i = 0; i < SIZE(variants); ++i) {
    if (variants.at(i) == -1) continue;
    if (!any_type_ingredient_in_header(variants.at(i))) continue;
    if (all_concrete_header_reagents_strictly_match(inst, get(Recipe, variants.at(i))))
      result.push_back(variants.at(i));
  }
  return result;
}

bool all_concrete_header_reagents_strictly_match(const instruction& inst, const recipe& variant) {
  if (SIZE(inst.ingredients) < SIZE(variant.ingredients)) {
    trace(9993, "transform") << "too few ingredients" << end();
    return false;
  }
  if (SIZE(variant.products) < SIZE(inst.products)) {
    trace(9993, "transform") << "too few products" << end();
    return false;
  }
  for (long long int i = 0; i < SIZE(variant.ingredients); ++i) {
    if (!concrete_type_names_strictly_match(variant.ingredients.at(i), inst.ingredients.at(i))) {
      trace(9993, "transform") << "concrete-type match failed: ingredient " << i << end();
      return false;
    }
  }
  for (long long int i = 0; i < SIZE(inst.products); ++i) {
    if (is_dummy(inst.products.at(i))) continue;
    if (!concrete_type_names_strictly_match(variant.products.at(i), inst.products.at(i))) {
      trace(9993, "transform") << "strict match failed: product " << i << end();
      return false;
    }
  }
  return true;
}

// tie-breaker for phase 2
recipe_ordinal best_shape_shifting_variant(const instruction& inst, vector<recipe_ordinal>& candidates) {
  assert(!candidates.empty());
  // primary score
  long long int max_score = -1;
  for (long long int i = 0; i < SIZE(candidates); ++i) {
    long long int score = number_of_concrete_type_names(candidates.at(i));
    assert(score > -1);
    if (score > max_score) max_score = score;
  }
  // break any ties at max_score by a secondary score
  long long int min_score2 = 999;
  long long int best_index = 0;
  for (long long int i = 0; i < SIZE(candidates); ++i) {
    long long int score1 = number_of_concrete_type_names(candidates.at(i));
    assert(score1 <= max_score);
    if (score1 != max_score) continue;
    const recipe& candidate = get(Recipe, candidates.at(i));
    long long int score2 = (SIZE(candidate.products)-SIZE(inst.products))
                           + (SIZE(inst.ingredients)-SIZE(candidate.ingredients));
    assert(score2 < 999);
    if (score2 < min_score2) {
      min_score2 = score2;
      best_index = i;
    }
  }
  return candidates.at(best_index);
}

bool any_type_ingredient_in_header(recipe_ordinal variant) {
  const recipe& caller = get(Recipe, variant);
  for (long long int i = 0; i < SIZE(caller.ingredients); ++i) {
    if (contains_type_ingredient_name(caller.ingredients.at(i)))
      return true;
  }
  for (long long int i = 0; i < SIZE(caller.products); ++i) {
    if (contains_type_ingredient_name(caller.products.at(i)))
      return true;
  }
  return false;
}

bool concrete_type_names_strictly_match(reagent to, reagent from) {
  canonize_type(to);
  canonize_type(from);
  return concrete_type_names_strictly_match(to.type, from.type, from);
}

long long int number_of_concrete_type_names(recipe_ordinal r) {
  const recipe& caller = get(Recipe, r);
  long long int result = 0;
  for (long long int i = 0; i < SIZE(caller.ingredients); ++i)
    result += number_of_concrete_type_names(caller.ingredients.at(i));
  for (long long int i = 0; i < SIZE(caller.products); ++i)
    result += number_of_concrete_type_names(caller.products.at(i));
  return result;
}

long long int number_of_concrete_type_names(const reagent& r) {
  return number_of_concrete_type_names(r.type);
}

long long int number_of_concrete_type_names(const type_tree* type) {
  if (!type) return 0;
  long long int result = 0;
  if (!type->name.empty() && !is_type_ingredient_name(type->name))
    result++;
  result += number_of_concrete_type_names(type->left);
  result += number_of_concrete_type_names(type->right);
  return result;
}

bool concrete_type_names_strictly_match(const type_tree* to, const type_tree* from, const reagent& rhs_reagent) {
  if (!to) return !from;
  if (!from) return !to;
  if (is_type_ingredient_name(to->name)) return true;  // type ingredient matches anything
  if (to->name == "literal" && from->name == "literal")
    return true;
  if (to->name == "literal"
      && Literal_type_names.find(from->name) != Literal_type_names.end())
    return true;
  if (from->name == "literal"
      && Literal_type_names.find(to->name) != Literal_type_names.end())
    return true;
  if (from->name == "literal" && to->name == "address")
    return rhs_reagent.name == "0";
  return to->name == from->name
      && concrete_type_names_strictly_match(to->left, from->left, rhs_reagent)
      && concrete_type_names_strictly_match(to->right, from->right, rhs_reagent);
}

bool contains_type_ingredient_name(const reagent& x) {
  return contains_type_ingredient_name(x.type);
}

bool contains_type_ingredient_name(const type_tree* type) {
  if (!type) return false;
  if (is_type_ingredient_name(type->name)) return true;
  return contains_type_ingredient_name(type->left) || contains_type_ingredient_name(type->right);
}

recipe_ordinal new_variant(recipe_ordinal exemplar, const instruction& inst, const recipe& caller_recipe) {
  cerr << "HHH " << contains_key(Type_ordinal, "_elem") << '\n';
  string new_name = next_unused_recipe_name(inst.name);
  assert(!contains_key(Recipe_ordinal, new_name));
  recipe_ordinal new_recipe_ordinal = put(Recipe_ordinal, new_name, Next_recipe_ordinal++);
  // make a copy
  assert(contains_key(Recipe, exemplar));
  assert(!contains_key(Recipe, new_recipe_ordinal));
  Recently_added_recipes.push_back(new_recipe_ordinal);
  Recently_added_shape_shifting_recipes.push_back(new_recipe_ordinal);
  put(Recipe, new_recipe_ordinal, get(Recipe, exemplar));
  recipe& new_recipe = get(Recipe, new_recipe_ordinal);
  new_recipe.name = new_name;
  trace(9993, "transform") << "switching " << inst.name << " to specialized " << header_label(new_recipe_ordinal) << end();
  // Since the exemplar never ran any transforms, we have to redo some of the
  // work of the check_types_by_name transform while supporting type-ingredients.
  compute_type_names(new_recipe);
  // that gives enough information to replace type-ingredients with concrete types
  {
    map<string, const type_tree*> mappings;
    bool error = false;
  cerr << "III " << contains_key(Type_ordinal, "_elem") << '\n';
    compute_type_ingredient_mappings(get(Recipe, exemplar), inst, mappings, caller_recipe, &error);
  cerr << "JJJ " << contains_key(Type_ordinal, "_elem") << '\n';
    if (!error) replace_type_ingredients(new_recipe, mappings);
  cerr << "VVV " << contains_key(Type_ordinal, "_elem") << '\n';
//?     if (!is_type_ingredient_name(x.type->name) && contains_key(Type_ordinal, x.type->name)) {
//?       x.type->value = get(Type_ordinal, x.type->name);
//?       return;
//?     }
    for (map<string, const type_tree*>::iterator p = mappings.begin(); p != mappings.end(); ++p)
      delete p->second;
    if (error) return 0;  // todo: delete new_recipe_ordinal from Recipes and other global state
  }
  ensure_all_concrete_types(new_recipe, get(Recipe, exemplar));
  cerr << "WWW " << contains_key(Type_ordinal, "_elem") << '\n';
  return new_recipe_ordinal;
}

void compute_type_names(recipe& variant) {
  trace(9993, "transform") << "compute type names: " << variant.name << end();
  map<string, type_tree*> type_names;
  for (long long int i = 0; i < SIZE(variant.ingredients); ++i)
    save_or_deduce_type_name(variant.ingredients.at(i), type_names, variant);
  for (long long int i = 0; i < SIZE(variant.products); ++i)
    save_or_deduce_type_name(variant.products.at(i), type_names, variant);
  for (long long int i = 0; i < SIZE(variant.steps); ++i) {
    instruction& inst = variant.steps.at(i);
    trace(9993, "transform") << "  instruction: " << to_string(inst) << end();
    for (long long int in = 0; in < SIZE(inst.ingredients); ++in)
      save_or_deduce_type_name(inst.ingredients.at(in), type_names, variant);
    for (long long int out = 0; out < SIZE(inst.products); ++out)
      save_or_deduce_type_name(inst.products.at(out), type_names, variant);
  }
}

void save_or_deduce_type_name(reagent& x, map<string, type_tree*>& type, const recipe& variant) {
  trace(9994, "transform") << "    checking " << to_string(x) << ": " << names_to_string(x.type) << end();
  if (!x.type && contains_key(type, x.name)) {
    x.type = new type_tree(*get(type, x.name));
    trace(9994, "transform") << "    deducing type to " << names_to_string(x.type) << end();
    return;
  }
  if (!x.type) {
    raise_error << maybe(variant.original_name) << "unknown type for " << x.original_string << " (check the name for typos)\n" << end();
    return;
  }
  if (contains_key(type, x.name)) return;
  if (x.type->name == "offset" || x.type->name == "variant") return;  // special-case for container-access instructions
  put(type, x.name, x.type);
  trace(9993, "transform") << "type of " << x.name << " is " << names_to_string(x.type) << end();
}

void compute_type_ingredient_mappings(const recipe& exemplar, const instruction& inst, map<string, const type_tree*>& mappings, const recipe& caller_recipe, bool* error) {
  long long int limit = min(SIZE(inst.ingredients), SIZE(exemplar.ingredients));
  for (long long int i = 0; i < limit; ++i) {
    const reagent& exemplar_reagent = exemplar.ingredients.at(i);
    reagent ingredient = inst.ingredients.at(i);
    canonize_type(ingredient);
    if (is_mu_address(exemplar_reagent) && ingredient.name == "0") continue;  // assume it matches
    accumulate_type_ingredients(exemplar_reagent, ingredient, mappings, exemplar, inst, caller_recipe, error);
  }
  limit = min(SIZE(inst.products), SIZE(exemplar.products));
  for (long long int i = 0; i < limit; ++i) {
    const reagent& exemplar_reagent = exemplar.products.at(i);
    reagent product = inst.products.at(i);
    canonize_type(product);
    accumulate_type_ingredients(exemplar_reagent, product, mappings, exemplar, inst, caller_recipe, error);
  }
}

inline long long int min(long long int a, long long int b) {
  return (a < b) ? a : b;
}

void accumulate_type_ingredients(const reagent& exemplar_reagent, reagent& refinement, map<string, const type_tree*>& mappings, const recipe& exemplar, const instruction& call_instruction, const recipe& caller_recipe, bool* error) {
  assert(refinement.type);
  accumulate_type_ingredients(exemplar_reagent.type, refinement.type, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error);
}

void accumulate_type_ingredients(const type_tree* exemplar_type, const type_tree* refinement_type, map<string, const type_tree*>& mappings, const recipe& exemplar, const reagent& exemplar_reagent, const instruction& call_instruction, const recipe& caller_recipe, bool* error) {
  if (!exemplar_type) return;
  if (!refinement_type) {
    // todo: make this smarter; only warn if exemplar_type contains some *new* type ingredient
    raise_error << maybe(exemplar.name) << "missing type ingredient in " << exemplar_reagent.original_string << '\n' << end();
    return;
  }
  if (is_type_ingredient_name(exemplar_type->name)) {
    assert(!refinement_type->name.empty());
    if (exemplar_type->right) {
      raise_error << "type_ingredients in non-last position not currently supported\n" << end();
      return;
    }
    if (!contains_key(mappings, exemplar_type->name)) {
      trace(9993, "transform") << "adding mapping from " << exemplar_type->name << " to " << to_string(refinement_type) << end();
      put(mappings, exemplar_type->name, new type_tree(*refinement_type));
    }
    else {
      if (!deeply_equal_type_names(get(mappings, exemplar_type->name), refinement_type)) {
        raise_error << maybe(caller_recipe.name) << "no call found for '" << to_string(call_instruction) << "'\n" << end();
        *error = true;
        return;
      }
      if (get(mappings, exemplar_type->name)->name == "literal") {
        delete get(mappings, exemplar_type->name);
        put(mappings, exemplar_type->name, new type_tree(*refinement_type));
      }
    }
  }
  else {
    accumulate_type_ingredients(exemplar_type->left, refinement_type->left, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error);
  }
  accumulate_type_ingredients(exemplar_type->right, refinement_type->right, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error);
}

void replace_type_ingredients(recipe& new_recipe, const map<string, const type_tree*>& mappings) {
  cerr << "KKK " << contains_key(Type_ordinal, "_elem") << '\n';
  // update its header
  if (mappings.empty()) return;
  cerr << "LLL " << contains_key(Type_ordinal, "_elem") << '\n';
  trace(9993, "transform") << "replacing in recipe header ingredients" << end();
  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i)
    replace_type_ingredients(new_recipe.ingredients.at(i), mappings, new_recipe);
  cerr << "MMM " << contains_key(Type_ordinal, "_elem") << '\n';
  trace(9993, "transform") << "replacing in recipe header products" << end();
  for (long long int i = 0; i < SIZE(new_recipe.products); ++i)
    replace_type_ingredients(new_recipe.products.at(i), mappings, new_recipe);
  // update its body
  cerr << "NNN " << contains_key(Type_ordinal, "_elem") << '\n';
  for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) {
    cerr << "OOO " << i << ' ' << contains_key(Type_ordinal, "_elem") << ' ' << to_string(new_recipe.steps.at(i)) << '\n';
    instruction& inst = new_recipe.steps.at(i);
    trace(9993, "transform") << "replacing in instruction '" << to_string(inst) << "'" << end();
    for (long long int j = 0; j < SIZE(inst.ingredients); ++j)
      replace_type_ingredients(inst.ingredients.at(j), mappings, new_recipe);
    for (long long int j = 0; j < SIZE(inst.products); ++j)
      replace_type_ingredients(inst.products.at(j), mappings, new_recipe);
    // special-case for new: replace type ingredient in first ingredient *value*
    if (inst.name == "new" && inst.ingredients.at(0).type->name != "literal-string") {
    cerr << "PPP " << contains_key(Type_ordinal, "_elem") << '\n';
      type_tree* type = parse_type_tree(inst.ingredients.at(0).name);
    cerr << "QQQ " << contains_key(Type_ordinal, "_elem") << '\n';
      replace_type_ingredients(type, mappings);
    cerr << "RRR " << contains_key(Type_ordinal, "_elem") << '\n';
      inst.ingredients.at(0).name = inspect(type);
      delete type;
    cerr << "SSS " << contains_key(Type_ordinal, "_elem") << '\n';
    }
  }
  cerr << "TTT " << contains_key(Type_ordinal, "_elem") << '\n';
}

void replace_type_ingredients(reagent& x, const map<string, const type_tree*>& mappings, const recipe& caller) {
  string before = to_string(x);
  trace(9993, "transform") << "replacing in ingredient " << x.original_string << end();
  if (!x.type) {
    raise_error << "specializing " << caller.original_name << ": missing type for " << x.original_string << '\n' << end();
    return;
  }
  replace_type_ingredients(x.type, mappings);
}

void replace_type_ingredients(type_tree* type, const map<string, const type_tree*>& mappings) {
  if (!type) return;
  if (contains_key(Type_ordinal, type->name))
    type->value = get(Type_ordinal, type->name);
  if (is_type_ingredient_name(type->name) && contains_key(mappings, type->name)) {
    const type_tree* replacement = get(mappings, type->name);
    //TODO names_to_string
    trace(9993, "transform") << type->name << " => " << to_string(replacement) << end();
    if (replacement->name == "literal") {
      type->name = "number";
      type->value = get(Type_ordinal, "number");
    }
    else {
      type->name = replacement->name;
      type->value = replacement->value;
    }
    if (replacement->left) type->left = new type_tree(*replacement->left);
    if (replacement->right) type->right = new type_tree(*replacement->right);
  }
  replace_type_ingredients(type->left, mappings);
  replace_type_ingredients(type->right, mappings);
}

type_tree* parse_type_tree(const string& s) {
  istringstream in(s);
  in >> std::noskipws;
  return parse_type_tree(in);
}

type_tree* parse_type_tree(istream& in) {
  skip_whitespace_but_not_newline(in);
  if (!has_data(in)) return NULL;
  if (in.peek() == ')') {
    in.get();
    return NULL;
  }
  if (in.peek() != '(') {
    string type_name = next_word(in);
    if (!contains_key(Type_ordinal, type_name))
      put(Type_ordinal, type_name, Next_type_ordinal++);
    type_tree* result = new type_tree(type_name, get(Type_ordinal, type_name));
    return result;
  }
  in.get();  // skip '('
  type_tree* result = NULL;
  type_tree** curr = &result;
  while (in.peek() != ')') {
    assert(has_data(in));
    *curr = new type_tree("", 0);
    skip_whitespace_but_not_newline(in);
    if (in.peek() == '(')
      (*curr)->left = parse_type_tree(in);
    else {
      (*curr)->name = next_word(in);
      if (!is_type_ingredient_name((*curr)->name)) {
        if (!contains_key(Type_ordinal, (*curr)->name)) {
          cerr << "RRR aaa " << contains_key(Type_ordinal, "_elem") << '\n';
          put(Type_ordinal, (*curr)->name, Next_type_ordinal++);
          cerr << ">>> RRR zzz " << contains_key(Type_ordinal, "_elem") << '\n';
        }
        (*curr)->value = get(Type_ordinal, (*curr)->name);
      }
    }
    curr = &(*curr)->right;
  }
  in.get();  // skip ')'
  return result;
}

string inspect(const type_tree* x) {
  ostringstream out;
  dump_inspect(x, out);
  return out.str();
}

void dump_inspect(const type_tree* x, ostream& out) {
  if (!x->left && !x->right) {
    out << x->name;
    return;
  }
  out << '(';
  for (const type_tree* curr = x; curr; curr = curr->right) {
    if (curr != x) out << ' ';
    if (curr->left)
      dump_inspect(curr->left, out);
    else
      out << curr->name;
  }
  out << ')';
}

void ensure_all_concrete_types(/*const*/ recipe& new_recipe, const recipe& exemplar) {
  for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i)
    ensure_all_concrete_types(new_recipe.ingredients.at(i), exemplar);
  for (long long int i = 0; i < SIZE(new_recipe.products); ++i)
    ensure_all_concrete_types(new_recipe.products.at(i), exemplar);
  for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) {
    instruction& inst = new_recipe.steps.at(i);
    for (long long int j = 0; j < SIZE(inst.ingredients); ++j)
      ensure_all_concrete_types(inst.ingredients.at(j), exemplar);
    for (long long int j = 0; j < SIZE(inst.products); ++j)
      ensure_all_concrete_types(inst.products.at(j), exemplar);
  }
}

void ensure_all_concrete_types(/*const*/ reagent& x, const recipe& exemplar) {
  if (!x.type || contains_type_ingredient_name(x.type)) {
    raise_error << maybe(exemplar.name) << "failed to map a type to " << x.original_string << '\n' << end();
    x.type = new type_tree("", 0);  // just to prevent crashes later
    return;
  }
  if (x.type->value == -1) {
    raise_error << maybe(exemplar.name) << "failed to map a type to the unknown " << x.original_string << '\n' << end();
    return;
  }
}

void test_shape_shifting_recipe_2() {
  Trace_file = "shape_shifting_recipe_2";
  run("recipe main [\n  10:point <- merge 14, 15\n  11:point <- foo 10:point\n]\n# non-matching shape-shifting variant\nrecipe foo a:_t, b:_t -> result:number [\n  local-scope\n  load-ingredients\n  result <- copy 34\n]\n# matching shape-shifting variant\nrecipe foo a:_t -> result:_t [\n  local-scope\n  load-ingredients\n  result <- copy a\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 11mem: storing 15 in location 12");
}
void test_shape_shifting_recipe_nonroot() {
  Trace_file = "shape_shifting_recipe_nonroot";
  run("recipe main [\n  10:foo:point <- merge 14, 15, 16\n  20:point/raw <- bar 10:foo:point\n]\n# shape-shifting recipe with type ingredient following some other type\nrecipe bar a:foo:_t -> result:_t [\n  local-scope\n  load-ingredients\n  result <- get a, x:offset\n]\ncontainer foo:_t [\n  x:_t\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 20mem: storing 15 in location 21");
}
void test_shape_shifting_recipe_type_deduction_ignores_offsets() {
  Trace_file = "shape_shifting_recipe_type_deduction_ignores_offsets";
  run("recipe main [\n  10:foo:point <- merge 14, 15, 16\n  20:point/raw <- bar 10:foo:point\n]\nrecipe bar a:foo:_t -> result:_t [\n  local-scope\n  load-ingredients\n  x:number <- copy 1\n  result <- get a, x:offset  # shouldn't collide with other variable\n]\ncontainer foo:_t [\n  x:_t\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 14 in location 20mem: storing 15 in location 21");
}
void test_shape_shifting_recipe_empty() {
  Trace_file = "shape_shifting_recipe_empty";
  run("recipe main [\n  foo 1\n]\n# shape-shifting recipe with no body\nrecipe foo a:_t [\n]\n# shouldn't crash\n");
}
void test_shape_shifting_recipe_handles_shape_shifting_new_ingredient() {
  Trace_file = "shape_shifting_recipe_handles_shape_shifting_new_ingredient";
  run("recipe main [\n  1:address:shared:foo:point <- bar 3\n  11:foo:point <- copy *1:address:shared:foo:point\n]\ncontainer foo:_t [\n  x:_t\n  y:number\n]\nrecipe bar x:number -> result:address:shared:foo:_t [\n  local-scope\n  load-ingredients\n  # new refers to _t in its ingredient *value*\n  result <- new {(foo _t) : type}\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 11mem: storing 0 in location 12mem: storing 0 in location 13");
}
void test_shape_shifting_recipe_handles_shape_shifting_new_ingredient_2() {
  Trace_file = "shape_shifting_recipe_handles_shape_shifting_new_ingredient_2";
  run("recipe main [\n  1:address:shared:foo:point <- bar 3\n  11:foo:point <- copy *1:address:shared:foo:point\n]\nrecipe bar x:number -> result:address:shared:foo:_t [\n  local-scope\n  load-ingredients\n  # new refers to _t in its ingredient *value*\n  result <- new {(foo _t) : type}\n]\n# container defined after use\ncontainer foo:_t [\n  x:_t\n  y:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 11mem: storing 0 in location 12mem: storing 0 in location 13");
}
void test_shape_shifting_recipe_supports_compound_types() {
  Trace_file = "shape_shifting_recipe_supports_compound_types";
  run("recipe main [\n  1:address:shared:point <- new point:type\n  2:address:number <- get-address *1:address:shared:point, y:offset\n  *2:address:number <- copy 34\n  3:address:shared:point <- bar 1:address:shared:point  # specialize _t to address:shared:point\n  4:point <- copy *3:address:shared:point\n]\nrecipe bar a:_t -> result:_t [\n  local-scope\n  load-ingredients\n  result <- copy a\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 5");
}
void test_shape_shifting_recipe_error() {
  Trace_file = "shape_shifting_recipe_error";
  Hide_errors = true;
  run("recipe main [\n  a:number <- copy 3\n  b:address:shared:number <- foo a\n]\nrecipe foo a:_t -> b:_t [\n  load-ingredients\n  b <- copy a\n]\n");
  CHECK_TRACE_CONTENTS("error: main: no call found for 'b:address:shared:number <- foo a'");
}
void test_specialize_inside_recipe_without_header() {
  Trace_file = "specialize_inside_recipe_without_header";
  run("recipe main [\n  foo 3\n]\nrecipe foo [\n  local-scope\n  x:number <- next-ingredient  # ensure no header\n  1:number/raw <- bar x  # call a shape-shifting recipe\n]\nrecipe bar x:_elem -> y:_elem [\n  local-scope\n  load-ingredients\n  y <- add x, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_specialize_with_literal() {
  Trace_file = "specialize_with_literal";
  run("recipe main [\n  local-scope\n  # permit literal to map to number\n  1:number/raw <- foo 3\n]\nrecipe foo x:_elem -> y:_elem [\n  local-scope\n  load-ingredients\n  y <- add x, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_specialize_with_literal_2() {
  Trace_file = "specialize_with_literal_2";
  run("recipe main [\n  local-scope\n  # permit literal to map to character\n  1:character/raw <- foo 3\n]\nrecipe foo x:_elem -> y:_elem [\n  local-scope\n  load-ingredients\n  y <- add x, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 1");
}
void test_specialize_with_literal_3() {
  Trace_file = "specialize_with_literal_3";
  Hide_errors = true;
  run("recipe main [\n  local-scope\n  # permit '0' to map to address to shape-shifting type-ingredient\n  1:address:shared:character/raw <- foo 0\n]\nrecipe foo x:address:_elem -> y:address:_elem [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 1");
  CHECK_TRACE_COUNT("error", 0);
}
void test_specialize_with_literal_4() {
  Trace_file = "specialize_with_literal_4";
  Hide_errors = true;
  run("recipe main [\n  local-scope\n  # ambiguous call: what's the type of its ingredient?!\n  foo 0\n]\nrecipe foo x:address:_elem -> y:address:_elem [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("error: foo: failed to map a type to xerror: foo: failed to map a type to y");
}
void test_specialize_with_literal_5() {
  Trace_file = "specialize_with_literal_5";
  run("recipe main [\n  foo 3, 4  # recipe mapping two variables to literals\n]\nrecipe foo x:_elem, y:_elem [\n  local-scope\n  load-ingredients\n  1:number/raw <- add x, y\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 7 in location 1");
}
void test_multiple_shape_shifting_variants() {
  Trace_file = "multiple_shape_shifting_variants";
  run("# try to call two different shape-shifting recipes with the same name\nrecipe main [\n  e1:d1:number <- merge 3\n  e2:d2:number <- merge 4, 5\n  1:number/raw <- foo e1\n  2:number/raw <- foo e2\n]\n# the two shape-shifting definitions\nrecipe foo a:d1:_elem -> b:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo a:d2:_elem -> b:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# the shape-shifting containers they use\ncontainer d1:_elem [\n  x:_elem\n]\ncontainer d2:_elem [\n  x:number\n  y:_elem\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1mem: storing 35 in location 2");
}
void test_multiple_shape_shifting_variants_2() {
  Trace_file = "multiple_shape_shifting_variants_2";
  run("# static dispatch between shape-shifting variants, _including pointer lookups_\nrecipe main [\n  e1:d1:number <- merge 3\n  e2:address:shared:d2:number <- new {(d2 number): type}\n  1:number/raw <- foo e1\n  2:number/raw <- foo *e2  # different from previous scenario\n]\nrecipe foo a:d1:_elem -> b:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo a:d2:_elem -> b:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\ncontainer d1:_elem [\n  x:_elem\n]\ncontainer d2:_elem [\n  x:number\n  y:_elem\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1mem: storing 35 in location 2");
}
void test_missing_type_in_shape_shifting_recipe() {
  Trace_file = "missing_type_in_shape_shifting_recipe";
  Hide_errors = true;
  run("recipe main [\n  a:d1:number <- merge 3\n  foo a\n]\nrecipe foo a:d1:_elem -> b:number [\n  local-scope\n  load-ingredients\n  copy e  # no such variable\n  reply 34\n]\ncontainer d1:_elem [\n  x:_elem\n]\n");
  CHECK_TRACE_CONTENTS("error: foo: unknown type for e (check the name for typos)error: specializing foo: missing type for e");
}
void test_missing_type_in_shape_shifting_recipe_2() {
  Trace_file = "missing_type_in_shape_shifting_recipe_2";
  Hide_errors = true;
  run("recipe main [\n  a:d1:number <- merge 3\n  foo a\n]\nrecipe foo a:d1:_elem -> b:number [\n  local-scope\n  load-ingredients\n  get e, x:offset  # unknown variable in a 'get', which does some extra checking\n  reply 34\n]\ncontainer d1:_elem [\n  x:_elem\n]\n");
  CHECK_TRACE_CONTENTS("error: foo: unknown type for e (check the name for typos)error: specializing foo: missing type for e");
}
void test_specialize_recursive_shape_shifting_recipe() {
  Trace_file = "specialize_recursive_shape_shifting_recipe";
  transform("recipe main [\n  1:number <- copy 34\n  2:number <- foo 1:number\n]\nrecipe foo x:_elem -> y:number [\n  local-scope\n  load-ingredients\n  {\n    break\n    y:number <- foo x\n  }\n  reply y\n]\n");
  CHECK_TRACE_CONTENTS("transform: new specialization: foo_2");
}
void test_specialize_most_similar_variant() {
  Trace_file = "specialize_most_similar_variant";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  2:number <- foo 1:address:shared:number\n]\nrecipe foo x:_elem -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:address:shared:_elem -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 35 in location 2");
}
void test_specialize_most_similar_variant_2() {
  Trace_file = "specialize_most_similar_variant_2";
  run("# version with headers padded with lots of unrelated concrete types\nrecipe main [\n  1:number <- copy 23\n  2:address:shared:array:number <- copy 0\n  3:number <- foo 2:address:shared:array:number, 1:number\n]\n# variant with concrete type\nrecipe foo dummy:address:shared:array:number, x:number -> y:number, dummy:address:shared:array:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\n# shape-shifting variant\nrecipe foo dummy:address:shared:array:number, x:_elem -> y:number, dummy:address:shared:array:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# prefer the concrete variant\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 3");
}
void test_specialize_most_similar_variant_3() {
  Trace_file = "specialize_most_similar_variant_3";
  run("recipe main [\n  1:address:shared:array:character <- new [abc]\n  foo 1:address:shared:array:character\n]\nrecipe foo x:address:shared:array:character [\n  2:number <- copy 34\n]\nrecipe foo x:address:_elem [\n  2:number <- copy 35\n]\n# make sure the more precise version was used\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
}
void test_specialize_literal_as_number() {
  Trace_file = "specialize_literal_as_number";
  run("recipe main [\n  1:number <- foo 23\n]\nrecipe foo x:_elem -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\nrecipe foo x:character -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}
void test_specialize_literal_as_number_2() {
  Trace_file = "specialize_literal_as_number_2";
  run("# version calling with literal\nrecipe main [\n  1:number <- foo 0\n]\n# variant with concrete type\nrecipe foo x:number -> y:number [\n  local-scope\n  load-ingredients\n  reply 34\n]\n# shape-shifting variant\nrecipe foo x:address:shared:_elem -> y:number [\n  local-scope\n  load-ingredients\n  reply 35\n]\n# prefer the concrete variant, ignore concrete types in scoring the shape-shifting variant\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}

void test_can_modify_value_ingredients() {
  Trace_file = "can_modify_value_ingredients";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:point <- new point:type\n  foo *p\n]\nrecipe foo p:point [\n  local-scope\n  load-ingredients\n  x:address:number <- get-address p, x:offset\n  *x <- copy 34\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}
void test_can_modify_ingredients_that_are_also_products() {
  Trace_file = "can_modify_ingredients_that_are_also_products";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:point <- new point:type\n  p <- foo p\n]\nrecipe foo p:address:shared:point -> p:address:shared:point [\n  local-scope\n  load-ingredients\n  x:address:number <- get-address *p, x:offset\n  *x <- copy 34\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}
void test_ignore_literal_ingredients_for_immutability_checks() {
  Trace_file = "ignore_literal_ingredients_for_immutability_checks";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:d1 <- new d1:type\n  q:number <- foo p\n]\nrecipe foo p:address:shared:d1 -> q:number [\n  local-scope\n  load-ingredients\n  x:address:shared:d1 <- new d1:type\n  y:address:number <- get-address *x, p:offset  # ignore this 'p'\n  q <- copy 34\n]\ncontainer d1 [\n  p:number\n  q:number\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}
void test_cannot_take_address_inside_immutable_ingredients() {
  Trace_file = "cannot_take_address_inside_immutable_ingredients";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:point <- new point:type\n  foo p\n]\nrecipe foo p:address:shared:point [\n  local-scope\n  load-ingredients\n  x:address:number <- get-address *p, x:offset\n  *x <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("warn: foo: cannot modify ingredient p after instruction 'x:address:number <- get-address *p, x:offset' because it's not also a product of foo");
}
void test_cannot_call_mutating_recipes_on_immutable_ingredients() {
  Trace_file = "cannot_call_mutating_recipes_on_immutable_ingredients";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:point <- new point:type\n  foo p\n]\nrecipe foo p:address:shared:point [\n  local-scope\n  load-ingredients\n  bar p\n]\nrecipe bar p:address:shared:point -> p:address:shared:point [\n  local-scope\n  load-ingredients\n  x:address:number <- get-address *p, x:offset\n  *x <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("warn: foo: cannot modify ingredient p at instruction 'bar p' because it's not also a product of foo");
}
void test_cannot_modify_copies_of_immutable_ingredients() {
  Trace_file = "cannot_modify_copies_of_immutable_ingredients";
  Hide_warnings = true;
  run("recipe main [\n  local-scope\n  p:address:shared:point <- new point:type\n  foo p\n]\nrecipe foo p:address:shared:point [\n  local-scope\n  load-ingredients\n  q:address:shared:point <- copy p\n  x:address:number <- get-address *q, x:offset\n]\n");
  CHECK_TRACE_CONTENTS("warn: foo: cannot modify q after instruction 'x:address:number <- get-address *q, x:offset' because that would modify ingredient p which is not also a product of foo");
}
void test_can_traverse_immutable_ingredients() {
  Trace_file = "can_traverse_immutable_ingredients";
  Hide_warnings = true;
  run("container test-list [\n  next:address:shared:test-list\n]\nrecipe main [\n  local-scope\n  p:address:shared:test-list <- new test-list:type\n  foo p\n]\nrecipe foo p:address:shared:test-list [\n  local-scope\n  load-ingredients\n  p2:address:shared:test-list <- bar p\n]\nrecipe bar x:address:shared:test-list -> y:address:shared:test-list [\n  local-scope\n  load-ingredients\n  y <- get *x, next:offset\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}
void test_handle_optional_ingredients_in_immutability_checks() {
  Trace_file = "handle_optional_ingredients_in_immutability_checks";
  Hide_warnings = true;
  run("recipe main [\n  k:address:shared:number <- new number:type\n  test k\n]\n# recipe taking an immutable address ingredient\nrecipe test k:address:shared:number [\n  local-scope\n  load-ingredients\n  foo k\n]\n# ..calling a recipe with an optional address ingredient\nrecipe foo -> [\n  local-scope\n  load-ingredients\n  k:address:shared:number, found?:boolean <- next-ingredient\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}
void check_immutable_ingredients(recipe_ordinal r) {
  // to ensure a reagent isn't modified, it suffices to show that we never
  // call get-address or index-address with it, and that any non-primitive
  // recipe calls in the body aren't returning it as a product.
  const recipe& caller = get(Recipe, r);
  trace(9991, "transform") << "--- check mutability of ingredients in recipe " << caller.name << end();
  if (!caller.has_header) return;  // skip check for old-style recipes calling next-ingredient directly
  for (long long int i = 0; i < SIZE(caller.ingredients); ++i) {
    const reagent& current_ingredient = caller.ingredients.at(i);
    if (!is_mu_address(current_ingredient)) continue;  // will be copied
    if (is_present_in_products(caller, current_ingredient.name)) continue;  // not expected to be immutable
    if (has_property(current_ingredient, "contained-in")) {
      const string_tree* tmp = property(current_ingredient, "contained-in");
      if (tmp->left || tmp->right
          || !is_present_in_ingredients(caller, tmp->value)
          || !is_present_in_products(caller, tmp->value))
        raise_error << maybe(caller.name) << "contained-in can only point to another ingredient+product, but got " << to_string(property(current_ingredient, "contained-in")) << '\n' << end();
      continue;
    }

    // End Immutable Ingredients Special-cases
    set<string> immutable_vars;
    immutable_vars.insert(current_ingredient.name);
    for (long long int i = 0; i < SIZE(caller.steps); ++i) {
      const instruction& inst = caller.steps.at(i);
      check_immutable_ingredient_in_instruction(inst, immutable_vars, current_ingredient.name, caller);
      update_aliases(inst, immutable_vars);
    }
  }
}

void update_aliases(const instruction& inst, set<string>& current_ingredient_and_aliases) {
  set<long long int> current_ingredient_indices = ingredient_indices(inst, current_ingredient_and_aliases);
  if (!contains_key(Recipe, inst.operation)) {
    // primitive recipe
    if (inst.operation == COPY) {
      for (set<long long int>::iterator p = current_ingredient_indices.begin(); p != current_ingredient_indices.end(); ++p) {
        current_ingredient_and_aliases.insert(inst.products.at(*p).name);
      }
    }
  }
  else {
    // defined recipe
    set<long long int> contained_in_product_indices = scan_contained_in_product_indices(inst, current_ingredient_indices);
    for (set<long long int>::iterator p = contained_in_product_indices.begin(); p != contained_in_product_indices.end(); ++p) {
      if (*p < SIZE(inst.products))
        current_ingredient_and_aliases.insert(inst.products.at(*p).name);
    }
  }
}

set<long long int> scan_contained_in_product_indices(const instruction& inst, set<long long int>& ingredient_indices) {
  set<string> selected_ingredient_names;
  const recipe& callee = get(Recipe, inst.operation);
  for (set<long long int>::iterator p = ingredient_indices.begin(); p != ingredient_indices.end(); ++p) {
    if (*p >= SIZE(callee.ingredients)) continue;  // optional immutable ingredient
    selected_ingredient_names.insert(callee.ingredients.at(*p).name);
  }
  set<long long int> result;
  for (long long int i = 0; i < SIZE(callee.products); ++i) {
    const reagent& current_product = callee.products.at(i);
    const string_tree* contained_in_name = property(current_product, "contained-in");
    if (contained_in_name && selected_ingredient_names.find(contained_in_name->value) != selected_ingredient_names.end())
      result.insert(i);
  }
  return result;
}

void test_immutability_infects_contained_in_variables() {
  Trace_file = "immutability_infects_contained_in_variables";
  Hide_warnings = true;
  transform("container test-list [\n  next:address:shared:test-list\n]\nrecipe main [\n  local-scope\n  p:address:shared:test-list <- new test-list:type\n  foo p\n]\nrecipe foo p:address:shared:test-list [  # p is immutable\n  local-scope\n  load-ingredients\n  p2:address:shared:test-list <- test-next p  # p2 is immutable\n  p3:address:address:shared:test-list <- get-address *p2, next:offset  # signal modification of p2\n]\nrecipe test-next x:address:shared:test-list -> y:address:shared:test-list/contained-in:x [\n  local-scope\n  load-ingredients\n  y <- get *x, next:offset\n]\n");
  CHECK_TRACE_CONTENTS("warn: foo: cannot modify p2 after instruction 'p3:address:address:shared:test-list <- get-address *p2, next:offset' because that would modify ingredient p which is not also a product of foo");
}
void check_immutable_ingredient_in_instruction(const instruction& inst, const set<string>& current_ingredient_and_aliases, const string& original_ingredient_name, const recipe& caller) {
  set<long long int> current_ingredient_indices = ingredient_indices(inst, current_ingredient_and_aliases);
  if (current_ingredient_indices.empty()) return;  // ingredient not found in call
  for (set<long long int>::iterator p = current_ingredient_indices.begin(); p != current_ingredient_indices.end(); ++p) {
    const long long int current_ingredient_index = *p;
    reagent current_ingredient = inst.ingredients.at(current_ingredient_index);
    canonize_type(current_ingredient);
    const string& current_ingredient_name = current_ingredient.name;
    if (!contains_key(Recipe, inst.operation)) {
      // primitive recipe
      if (inst.operation == GET_ADDRESS || inst.operation == INDEX_ADDRESS) {
        if (current_ingredient_name == original_ingredient_name)
          raise << maybe(caller.name) << "cannot modify ingredient " << current_ingredient_name << " after instruction '" << to_string(inst) << "' because it's not also a product of " << caller.name << '\n' << end();
        else
          raise << maybe(caller.name) << "cannot modify " << current_ingredient_name << " after instruction '" << to_string(inst) << "' because that would modify ingredient " << original_ingredient_name << " which is not also a product of " << caller.name << '\n' << end();
      }
    }
    else {
      // defined recipe
      if (!is_mu_address(current_ingredient)) return;  // making a copy is ok
      if (is_modified_in_recipe(inst.operation, current_ingredient_index, caller)) {
        if (current_ingredient_name == original_ingredient_name)
          raise << maybe(caller.name) << "cannot modify ingredient " << current_ingredient_name << " at instruction '" << to_string(inst) << "' because it's not also a product of " << caller.name << '\n' << end();
        else
          raise << maybe(caller.name) << "cannot modify " << current_ingredient_name << " after instruction '" << to_string(inst) << "' because that would modify ingredient " << original_ingredient_name << " which is not also a product of " << caller.name << '\n' << end();
      }
    }
  }
}

bool is_modified_in_recipe(recipe_ordinal r, long long int ingredient_index, const recipe& caller) {
  const recipe& callee = get(Recipe, r);
  if (!callee.has_header) {
    raise << maybe(caller.name) << "can't check mutability of ingredients in " << callee.name << " because it uses 'next-ingredient' directly, rather than a recipe header.\n" << end();
    return true;
  }
  if (ingredient_index >= SIZE(callee.ingredients)) return false;  // optional immutable ingredient
  return is_present_in_products(callee, callee.ingredients.at(ingredient_index).name);
}

bool is_present_in_products(const recipe& callee, const string& ingredient_name) {
  for (long long int i = 0; i < SIZE(callee.products); ++i) {
    if (callee.products.at(i).name == ingredient_name)
      return true;
  }
  return false;
}

bool is_present_in_ingredients(const recipe& callee, const string& ingredient_name) {
  for (long long int i = 0; i < SIZE(callee.ingredients); ++i) {
    if (callee.ingredients.at(i).name == ingredient_name)
      return true;
  }
  return false;
}

set<long long int> ingredient_indices(const instruction& inst, const set<string>& ingredient_names) {
  set<long long int> result;
  for (long long int i = 0; i < SIZE(inst.ingredients); ++i) {
    if (is_literal(inst.ingredients.at(i))) continue;
    if (ingredient_names.find(inst.ingredients.at(i).name) != ingredient_names.end())
      result.insert(i);
  }
  return result;
}


void test_can_modify_contained_in_addresses() {
  Trace_file = "can_modify_contained_in_addresses";
  Hide_warnings = true;
  transform("container test-list [\n  next:address:shared:test-list\n]\nrecipe main [\n  local-scope\n  p:address:shared:test-list <- new test-list:type\n  foo p\n]\nrecipe foo p:address:shared:test-list -> p:address:shared:test-list [\n  local-scope\n  load-ingredients\n  p2:address:shared:test-list <- test-next p\n  p <- test-remove p2, p\n]\nrecipe test-next x:address:shared:test-list -> y:address:shared:test-list [\n  local-scope\n  load-ingredients\n  y <- get *x, next:offset\n]\nrecipe test-remove x:address:shared:test-list/contained-in:from, from:address:shared:test-list -> from:address:shared:test-list [\n  local-scope\n  load-ingredients\n  x2:address:address:shared:test-list <- get-address *x, next:offset  # pretend modification\n]\n");
  CHECK_TRACE_COUNT("warn", 0);
}

void test_call_literal_recipe() {
  Trace_file = "call_literal_recipe";
  run("recipe main [\n  1:number <- call f, 34\n]\nrecipe f x:number -> y:number [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}
void test_call_variable() {
  Trace_file = "call_variable";
  run("recipe main [\n  {1: (recipe number -> number)} <- copy f\n  2:number <- call {1: (recipe number -> number)}, 34\n]\nrecipe f x:number -> y:number [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
}
void test_call_check_literal_recipe() {
  Trace_file = "call_check_literal_recipe";
  Hide_errors = true;
  run("recipe main [\n  1:number <- call f, 34\n]\nrecipe f x:boolean -> y:boolean [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("error: main: ingredient 0 has the wrong type at '1:number <- call f, 34'error: main: product 0 has the wrong type at '1:number <- call f, 34'");
}
void test_call_check_variable_recipe() {
  Trace_file = "call_check_variable_recipe";
  Hide_errors = true;
  run("recipe main [\n  {1: (recipe boolean -> boolean)} <- copy f\n  2:number <- call {1: (recipe boolean -> boolean)}, 34\n]\nrecipe f x:boolean -> y:boolean [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("error: main: ingredient 0 has the wrong type at '2:number <- call {1: (recipe boolean -> boolean)}, 34'error: main: product 0 has the wrong type at '2:number <- call {1: (recipe boolean -> boolean)}, 34'");
}
void check_indirect_calls_against_header(const recipe_ordinal r) {
  trace(9991, "transform") << "--- type-check 'call' instructions inside recipe " << get(Recipe, r).name << end();
  const recipe& caller = get(Recipe, r);
  for (long long int i = 0; i < SIZE(caller.steps); ++i) {
    const instruction& inst = caller.steps.at(i);
    if (inst.operation != CALL) continue;
    if (inst.ingredients.empty()) continue;  // error raised above
    const reagent& callee = inst.ingredients.at(0);
    if (!is_mu_recipe(callee)) continue;  // error raised above
    const recipe callee_header = is_literal(callee) ? get(Recipe, callee.value) : from_reagent(inst.ingredients.at(0));
    if (!callee_header.has_header) continue;
    for (long int i = /*skip callee*/1; i < min(SIZE(inst.ingredients), SIZE(callee_header.ingredients)+/*skip callee*/1); ++i) {
      if (!types_coercible(callee_header.ingredients.at(i-/*skip callee*/1), inst.ingredients.at(i)))
        raise_error << maybe(caller.name) << "ingredient " << i-/*skip callee*/1 << " has the wrong type at '" << to_string(inst) << "'\n" << end();
    }
    for (long int i = 0; i < min(SIZE(inst.products), SIZE(callee_header.products)); ++i) {
      if (is_dummy(inst.products.at(i))) continue;
      if (!types_coercible(callee_header.products.at(i), inst.products.at(i)))
        raise_error << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_string(inst) << "'\n" << end();
    }
  }
}

recipe from_reagent(const reagent& r) {
  assert(r.type->name == "recipe");
  recipe result_header;  // will contain only ingredients and products, nothing else
  result_header.has_header = true;
  const type_tree* curr = r.type->right;
  for (; curr; curr=curr->right) {
    if (curr->name == "->") {
      curr = curr->right;  // skip delimiter
      break;
    }
    result_header.ingredients.push_back("recipe:"+curr->name);
  }
  for (; curr; curr=curr->right)
    result_header.products.push_back("recipe:"+curr->name);
  return result_header;
}

bool is_mu_recipe(reagent r) {
  if (!r.type) return false;
  if (r.type->name == "recipe") return true;
  if (r.type->name == "recipe-literal") return true;
  // End is_mu_recipe Cases
  return false;
}

void test_copy_typecheck_recipe_variable() {
  Trace_file = "copy_typecheck_recipe_variable";
  Hide_errors = true;
  run("recipe main [\n  3:number <- copy 34  # abc def\n  {1: (recipe number -> number)} <- copy f  # store literal in a matching variable\n  {2: (recipe boolean -> boolean)} <- copy {1: (recipe number -> number)}  # mismatch between recipe variables\n]\nrecipe f x:number -> y:number [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy {1: (recipe number -> number)} to {2: (recipe boolean -> boolean)}; types don't match");
}
void test_copy_typecheck_recipe_variable_2() {
  Trace_file = "copy_typecheck_recipe_variable_2";
  Hide_errors = true;
  run("recipe main [\n  {1: (recipe number -> number)} <- copy f  # mismatch with a recipe literal\n]\nrecipe f x:boolean -> y:boolean [\n  local-scope\n  load-ingredients\n  y <- copy x\n]\n");
  CHECK_TRACE_CONTENTS("error: main: can't copy f to {1: (recipe number -> number)}; types don't match");
}

void test_scheduler() {
  Trace_file = "scheduler";
  run("recipe f1 [\n  start-running f2\n  # wait for f2 to run\n  {\n    jump-unless 1:number, -1\n  }\n]\nrecipe f2 [\n  1:number <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("schedule: f1schedule: f2");
}
void run(routine* rr) {
  Routines.push_back(rr);
  Current_routine_index = 0, Current_routine = Routines.at(0);
  while (!all_routines_done()) {
    skip_to_next_routine();
    assert(Current_routine);
    assert(Current_routine->state == RUNNING);
    trace(9990, "schedule") << current_routine_label() << end();
    run_current_routine(Scheduling_interval);
    // Scheduler State Transitions
    if (Current_routine->completed())
      Current_routine->state = COMPLETED;
    if (Current_routine->limit >= 0) {
      if (Current_routine->limit <= Scheduling_interval) {
        trace(9999, "schedule") << "discontinuing routine " << Current_routine->id << end();
        Current_routine->state = DISCONTINUED;
        Current_routine->limit = 0;
      }
      else {
        Current_routine->limit -= Scheduling_interval;
      }
    }

    for (long long int i = 0; i < SIZE(Routines); ++i) {
      if (Routines.at(i)->state != WAITING) continue;
      if (Routines.at(i)->waiting_on_location &&
          get_or_insert(Memory, Routines.at(i)->waiting_on_location) != Routines.at(i)->old_value_of_waiting_location) {
        trace(9999, "schedule") << "waking up routine\n" << end();
        Routines.at(i)->state = RUNNING;
        Routines.at(i)->waiting_on_location = Routines.at(i)->old_value_of_waiting_location = 0;
      }
    }


    // Wake up any routines waiting for other routines to go to sleep.
    // Important: this must come after the scheduler loop above giving routines
    // waiting for locations to change a chance to wake up.
    for (long long int i = 0; i < SIZE(Routines); ++i) {
      if (Routines.at(i)->state != WAITING) continue;
      if (!Routines.at(i)->waiting_on_routine) continue;
      long long int id = Routines.at(i)->waiting_on_routine;
      assert(id != Routines.at(i)->id);  // routine can't wait on itself
      for (long long int j = 0; j < SIZE(Routines); ++j) {
        if (Routines.at(j)->id == id && Routines.at(j)->state != RUNNING) {
          trace(9999, "schedule") << "waking up routine " << Routines.at(i)->id << end();
          Routines.at(i)->state = RUNNING;
          Routines.at(i)->waiting_on_routine = 0;
        }
      }
    }

    // End Scheduler State Transitions

    // Scheduler Cleanup
    for (long long int i = 0; i < SIZE(Routines); ++i) {
      if (Routines.at(i)->state == COMPLETED) continue;
      if (Routines.at(i)->parent_index < 0) continue;  // root thread
      if (has_completed_parent(i)) {
        Routines.at(i)->state = COMPLETED;
      }
    }

    // End Scheduler Cleanup
  }
}

bool all_routines_done() {
  for (long long int i = 0; i < SIZE(Routines); ++i) {
    if (Routines.at(i)->state == RUNNING) {
      return false;
    }
  }
  return true;
}

// skip Current_routine_index past non-RUNNING routines
void skip_to_next_routine() {
  assert(!Routines.empty());
  assert(Current_routine_index < SIZE(Routines));
  for (long long int i = (Current_routine_index+1)%SIZE(Routines);  i != Current_routine_index;  i = (i+1)%SIZE(Routines)) {
    if (Routines.at(i)->state == RUNNING) {
      Current_routine_index = i;
      Current_routine = Routines.at(i);
      return;
    }
  }
}

string current_routine_label() {
  ostringstream result;
  const call_stack& calls = Current_routine->calls;
  for (call_stack::const_iterator p = calls.begin(); p != calls.end(); ++p) {
    if (p != calls.begin()) result << '/';
    result << get(Recipe, p->running_recipe).name;
  }
  return result.str();
}

void test_scheduler_runs_single_routine() {
  Trace_file = "scheduler_runs_single_routine";
  Scheduling_interval = 1;
  run("recipe f1 [\n  1:number <- copy 0\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("schedule: f1run: 1:number <- copy 0schedule: f1run: 2:number <- copy 0");
}
void test_scheduler_interleaves_routines() {
  Trace_file = "scheduler_interleaves_routines";
  Scheduling_interval = 1;
  run("recipe f1 [\n  start-running f2\n  1:number <- copy 0\n  2:number <- copy 0\n]\nrecipe f2 [\n  3:number <- copy 0\n  4:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("schedule: f1run: start-running f2schedule: f2run: 3:number <- copy 0schedule: f1run: 1:number <- copy 0schedule: f2run: 4:number <- copy 0schedule: f1run: 2:number <- copy 0");
}
void test_start_running_takes_ingredients() {
  Trace_file = "start_running_takes_ingredients";
  run("recipe f1 [\n  start-running f2, 3\n  # wait for f2 to run\n  {\n    jump-unless 1:number, -1\n  }\n]\nrecipe f2 [\n  1:number <- next-ingredient\n  2:number <- add 1:number, 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 4 in location 2");
}
void test_start_running_returns_routine_id() {
  Trace_file = "start_running_returns_routine_id";
  run("recipe f1 [\n  1:number <- start-running f2\n]\nrecipe f2 [\n  12:number <- copy 44\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 2 in location 1");
}
void test_scheduler_skips_completed_routines() {
  Trace_file = "scheduler_skips_completed_routines";
  recipe_ordinal f1 = load("recipe f1 [\n1:number <- copy 0\n]\n").front();
  recipe_ordinal f2 = load("recipe f2 [\n2:number <- copy 0\n]\n").front();
  Routines.push_back(new routine(f1));  // f1 meant to run
  Routines.push_back(new routine(f2));
  Routines.back()->state = COMPLETED;  // f2 not meant to run
  run("# must have at least one routine without escaping\nrecipe f3 [\n  3:number <- copy 0\n]\n# by interleaving '+' lines with '-' lines, we allow f1 and f3 to run in any order\n");
  CHECK_TRACE_CONTENTS("schedule: f1mem: storing 0 in location 1");
  CHECK_TRACE_DOESNT_CONTAIN("schedule: f2");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 2");
  run("");
  CHECK_TRACE_CONTENTS("schedule: f3mem: storing 0 in location 3");
}
void test_scheduler_starts_at_middle_of_routines() {
  Trace_file = "scheduler_starts_at_middle_of_routines";
  Routines.push_back(new routine(COPY));
  Routines.back()->state = COMPLETED;
  run("recipe f1 [\n  1:number <- copy 0\n  2:number <- copy 0\n]\n");
  CHECK_TRACE_CONTENTS("schedule: f1");
  CHECK_TRACE_DOESNT_CONTAIN("run: idle");
}
void test_scheduler_terminates_routines_after_errors() {
  Trace_file = "scheduler_terminates_routines_after_errors";
  Hide_errors = true;
  Scheduling_interval = 2;
  run("recipe f1 [\n  start-running f2\n  1:number <- copy 0\n  2:number <- copy 0\n]\nrecipe f2 [\n  # divide by 0 twice\n  3:number <- divide-with-remainder 4, 0\n  4:number <- divide-with-remainder 4, 0\n]\n# f2 should stop after first divide by 0\n");
  CHECK_TRACE_CONTENTS("error: f2: divide by zero in '3:number <- divide-with-remainder 4, 0'");
  CHECK_TRACE_DOESNT_CONTAIN("error: f2: divide by zero in '4:number <- divide-with-remainder 4, 0'");
}
void test_scheduler_kills_orphans() {
  Trace_file = "scheduler_kills_orphans";
  run("recipe main [\n  start-running f1\n  # f1 never actually runs because its parent completes without waiting for it\n]\nrecipe f1 [\n  1:number <- copy 0\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("schedule: f1");
}
bool has_completed_parent(long long int routine_index) {
  for (long long int j = routine_index; j >= 0; j = Routines.at(j)->parent_index) {
    if (Routines.at(j)->state == COMPLETED)
      return true;
  }
  return false;
}


void test_routine_state_test() {
  Trace_file = "routine_state_test";
  Scheduling_interval = 2;
  run("recipe f1 [\n  1:number/child-id <- start-running f2\n  12:number <- copy 0  # race condition since we don't care about location 12\n  # thanks to Scheduling_interval, f2's one instruction runs in between here and completes\n  2:number/state <- routine-state 1:number/child-id\n]\nrecipe f2 [\n  12:number <- copy 0\n  # trying to run a second instruction marks routine as completed\n]\n# recipe f2 should be in state COMPLETED\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 2");
}
void test_routine_discontinues_past_limit() {
  Trace_file = "routine_discontinues_past_limit";
  Scheduling_interval = 2;
  run("recipe f1 [\n  1:number/child-id <- start-running f2\n  limit-time 1:number/child-id, 10\n  # padding loop just to make sure f2 has time to completed\n  2:number <- copy 20\n  2:number <- subtract 2:number, 1\n  jump-if 2:number, -2:offset\n]\nrecipe f2 [\n  jump -1:offset  # run forever\n  $print [should never get here], 10/newline\n]\n# f2 terminates\n");
  CHECK_TRACE_CONTENTS("schedule: discontinuing routine 2");
}
void test_new_concurrent() {
  Trace_file = "new_concurrent";
  run("recipe f1 [\n  start-running f2\n  1:address:shared:number/raw <- new number:type\n  # wait for f2 to complete\n  {\n    loop-unless 4:number/raw\n  }\n]\nrecipe f2 [\n  2:address:shared:number/raw <- new number:type\n  # hack: assumes scheduler implementation\n  3:boolean/raw <- equal 1:address:shared:number/raw, 2:address:shared:number/raw\n  # signal f2 complete\n  4:number/raw <- copy 1\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}

void test_wait_for_location() {
  Trace_file = "wait_for_location";
  run("recipe f1 [\n  1:number <- copy 0\n  start-running f2\n  wait-for-location 1:number\n  # now wait for f2 to run and modify location 1 before using its value\n  2:number <- copy 1:number\n]\nrecipe f2 [\n  1:number <- copy 34\n]\n# if we got the synchronization wrong we'd be storing 0 in location 2\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 2");
}
void test_wait_for_routine() {
  Trace_file = "wait_for_routine";
  run("recipe f1 [\n  1:number <- copy 0\n  12:number/routine <- start-running f2\n  wait-for-routine 12:number/routine\n  # now wait for f2 to run and modify location 1 before using its value\n  3:number <- copy 1:number\n]\nrecipe f2 [\n  1:number <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("schedule: f1run: waiting for routine 2schedule: f2schedule: waking up routine 1schedule: f1mem: storing 34 in location 3");
}
long long int some_other_running_routine() {
  for (long long int i = 0; i < SIZE(Routines); ++i) {
    if (i == Current_routine_index) continue;
    assert(Routines.at(i) != Current_routine);
    assert(Routines.at(i)->id != Current_routine->id);
    if (Routines.at(i)->state == RUNNING)
      return Routines.at(i)->id;
  }
  return 0;
}

void test_round_to_nearest_integer() {
  Trace_file = "round_to_nearest_integer";
  run("recipe main [\n  1:number <- round 12.2\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 12 in location 1");
}
// A universal hash function that can handle objects of any type.
//
// The way it's currently implemented, two objects will have the same hash if
// all their non-address fields (all the way down) expand to the same sequence
// of scalar values. In particular, a container with all zero addresses hashes
// to 0. Hopefully this won't be an issue because we are usually hashing
// objects of a single type in any given hash table.
//
// Based on http://burtleburtle.net/bob/hash/hashfaq.html

size_t hash(size_t h, reagent& r) {
//?   cerr << debug_string(r) << '\n';
  canonize(r);
  if (is_mu_string(r))  // optimization
    return hash_mu_string(h, r);
  else if (is_mu_address(r))
    return hash_mu_address(h, r);
  else if (is_mu_scalar(r))
    return hash_mu_scalar(h, r);
  else if (is_mu_array(r))
    return hash_mu_array(h, r);
  else if (is_mu_container(r))
    return hash_mu_container(h, r);
  else if (is_mu_exclusive_container(r))
    return hash_mu_exclusive_container(h, r);
  assert(false);
}

size_t hash_mu_scalar(size_t h, const reagent& r) {
  double input = is_literal(r) ? r.value : get_or_insert(Memory, r.value);
  return hash_iter(h, static_cast<size_t>(input));
}

size_t hash_mu_address(size_t h, reagent& r) {
  if (r.value == 0) return 0;
  r.value = get_or_insert(Memory, r.value);
  drop_from_type(r, "address");
  if (r.type->name == "shared") {
    ++r.value;
    drop_from_type(r, "shared");
  }
  return hash(h, r);
}

size_t hash_mu_string(size_t h, const reagent& r) {
  string input = read_mu_string(get_or_insert(Memory, r.value));
  for (long long int i = 0; i < SIZE(input); ++i) {
    h = hash_iter(h, static_cast<size_t>(input.at(i)));
//?     cerr << i << ": " << h << '\n';
  }
  return h;
}

size_t hash_mu_array(size_t h, const reagent& r) {
  long long int size = get_or_insert(Memory, r.value);
  reagent elem = r;
  delete elem.type;
  elem.type = new type_tree(*array_element(r.type));
  for (long long int i=0, address = r.value+1; i < size; ++i, address += size_of(elem)) {
    reagent tmp = elem;
    tmp.value = address;
    h = hash(h, tmp);
//?     cerr << i << " (" << address << "): " << h << '\n';
  }
  return h;
}

bool is_mu_container(const reagent& r) {
  if (r.type->value == 0) return false;
  type_info& info = get(Type, r.type->value);
  return info.kind == CONTAINER;
}

size_t hash_mu_container(size_t h, const reagent& r) {
  assert(r.type->value);
  type_info& info = get(Type, r.type->value);
  long long int address = r.value;
  long long int offset = 0;
  for (long long int i = 0; i < SIZE(info.elements); ++i) {
    reagent element = element_type(r, i);
    if (has_property(element, "ignore-for-hash")) continue;
    element.set_value(address+offset);
    h = hash(h, element);
//?     cerr << i << ": " << h << '\n';
    offset += size_of(info.elements.at(i).type);
  }
  return h;
}

bool is_mu_exclusive_container(const reagent& r) {
  if (r.type->value == 0) return false;
  type_info& info = get(Type, r.type->value);
  return info.kind == EXCLUSIVE_CONTAINER;
}

size_t hash_mu_exclusive_container(size_t h, const reagent& r) {
  assert(r.type->value);
  long long int tag = get(Memory, r.value);
  reagent variant = variant_type(r, tag);
  // todo: move this warning to container definition time
  if (has_property(variant, "ignore-for-hash"))
    raise << get(Type, r.type->value).name << ": /ignore-for-hash won't work in exclusive containers\n";
  variant.set_value(r.value + /*skip tag*/1);
  h = hash(h, variant);
  return h;
}

size_t hash_iter(size_t h, size_t input) {
  h += input;
  h += (h<<10);
  h ^= (h>>6);

  h += (h<<3);
  h ^= (h>>11);
  h += (h<<15);
  return h;
}

void test_hash_container_checks_all_elements() {
  Trace_file = "hash_container_checks_all_elements";
  run("container foo [\n  x:number\n  y:character\n]\nrecipe main [\n  1:foo <- merge 34, 97/a\n  3:number <- hash 1:foo\n  reply-unless 3:number\n  4:foo <- merge 34, 98/a\n  6:number <- hash 4:foo\n  reply-unless 6:number\n  7:boolean <- equal 3:number, 6:number\n]\n# hash on containers includes all elements\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 7");
}
void test_hash_exclusive_container_checks_all_elements() {
  Trace_file = "hash_exclusive_container_checks_all_elements";
  run("exclusive-container foo [\n  x:bar\n  y:number\n]\ncontainer bar [\n  a:number\n  b:number\n]\nrecipe main [\n  1:foo <- merge 0/x, 34, 35\n  4:number <- hash 1:foo\n  reply-unless 4:number\n  5:foo <- merge 0/x, 34, 36\n  8:number <- hash 5:foo\n  reply-unless 8:number\n  9:boolean <- equal 4:number, 8:number\n]\n# hash on containers includes all elements\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 9");
}
void test_hash_can_ignore_container_elements() {
  Trace_file = "hash_can_ignore_container_elements";
  run("container foo [\n  x:number\n  y:character/ignore-for-hash\n]\nrecipe main [\n  1:foo <- merge 34, 97/a\n  3:number <- hash 1:foo\n  reply-unless 3:number\n  4:foo <- merge 34, 98/a\n  6:number <- hash 4:foo\n  reply-unless 6:number\n  7:boolean <- equal 3:number, 6:number\n]\n# hashes match even though y is different\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 7");
}
void test_hash_of_zero_address() {
  Trace_file = "hash_of_zero_address";
  run("recipe main [\n  1:address:number <- copy 0\n  2:number <- hash 1:address:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2");
}
void test_hash_of_numbers_ignores_fractional_part() {
  Trace_file = "hash_of_numbers_ignores_fractional_part";
  run("recipe main [\n  1:number <- hash 1.5\n  2:number <- hash 1\n  3:boolean <- equal 1:number, 2:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 3");
}
void test_hash_of_array_same_as_string() {
  Trace_file = "hash_of_array_same_as_string";
  run("recipe main [\n  10:number <- copy 3\n  11:number <- copy 97\n  12:number <- copy 98\n  13:number <- copy 99\n  2:number <- hash 10:array:number/unsafe\n  reply-unless 2:number\n  3:address:shared:array:character <- new [abc]\n  4:number <- hash 3:address:shared:array:character\n  reply-unless 4:number\n  5:boolean <- equal 2:number, 4:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 5");
}
void test_hash_ignores_address_value() {
  Trace_file = "hash_ignores_address_value";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  *1:address:shared:number <- copy 34\n  2:number <- hash 1:address:shared:number\n  3:address:shared:number <- new number:type\n  *3:address:shared:number <- copy 34\n  4:number <- hash 3:address:shared:number\n  5:boolean <- equal 2:number, 4:number\n]\n# different addresses hash to the same result as long as the values the point to do so\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 5");
}
void test_hash_ignores_address_refcount() {
  Trace_file = "hash_ignores_address_refcount";
  run("recipe main [\n  1:address:shared:number <- new number:type\n  *1:address:shared:number <- copy 34\n  2:number <- hash 1:address:shared:number\n  reply-unless 2:number\n  # increment refcount\n  3:address:shared:number <- copy 1:address:shared:number\n  4:number <- hash 3:address:shared:number\n  reply-unless 4:number\n  5:boolean <- equal 2:number, 4:number\n]\n# hash doesn't change when refcount changes\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 5");
}
void test_hash_container_depends_only_on_elements() {
  Trace_file = "hash_container_depends_only_on_elements";
  run("container foo [\n  x:number\n  y:character\n]\ncontainer bar [\n  x:number\n  y:character\n]\nrecipe main [\n  1:foo <- merge 34, 97/a\n  3:number <- hash 1:foo\n  reply-unless 3:number\n  4:bar <- merge 34, 97/a\n  6:number <- hash 4:bar\n  reply-unless 6:number\n  7:boolean <- equal 3:number, 6:number\n]\n# containers with identical elements return identical hashes\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 7");
}
void test_hash_container_depends_only_on_elements_2() {
  Trace_file = "hash_container_depends_only_on_elements_2";
  run("container foo [\n  x:number\n  y:character\n  z:address:shared:number\n]\nrecipe main [\n  1:address:shared:number <- new number:type\n  *1:address:shared:number <- copy 34\n  2:foo <- merge 34, 97/a, 1:address:shared:number\n  5:number <- hash 2:foo\n  reply-unless 5:number\n  6:address:shared:number <- new number:type\n  *6:address:shared:number <- copy 34\n  7:foo <- merge 34, 97/a, 6:address:shared:number\n  10:number <- hash 7:foo\n  reply-unless 10:number\n  11:boolean <- equal 5:number, 10:number\n]\n# containers with identical 'leaf' elements return identical hashes\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 11");
}
void test_hash_container_depends_only_on_elements_3() {
  Trace_file = "hash_container_depends_only_on_elements_3";
  run("container foo [\n  x:number\n  y:character\n  z:bar\n]\ncontainer bar [\n  x:number\n  y:number\n]\nrecipe main [\n  1:foo <- merge 34, 97/a, 47, 48\n  6:number <- hash 1:foo\n  reply-unless 6:number\n  7:foo <- merge 34, 97/a, 47, 48\n  12:number <- hash 7:foo\n  reply-unless 12:number\n  13:boolean <- equal 6:number, 12:number\n]\n# containers with identical 'leaf' elements return identical hashes\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 13");
}
void test_hash_exclusive_container_ignores_tag() {
  Trace_file = "hash_exclusive_container_ignores_tag";
  run("exclusive-container foo [\n  x:bar\n  y:number\n]\ncontainer bar [\n  a:number\n  b:number\n]\nrecipe main [\n  1:foo <- merge 0/x, 34, 35\n  4:number <- hash 1:foo\n  reply-unless 4:number\n  5:bar <- merge 34, 35\n  7:number <- hash 5:bar\n  reply-unless 7:number\n  8:boolean <- equal 4:number, 7:number\n]\n# hash on containers includes all elements\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 8");
}
void test_hash_matches_old_version() {
  Trace_file = "hash_matches_old_version";
  run("recipe main [\n  1:address:shared:array:character <- new [abc]\n  2:number <- hash 1:address:shared:array:character\n  3:number <- hash_old 1:address:shared:array:character\n  4:number <- equal 2:number, 3:number\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 1 in location 4");
}



void test_convert_names_does_not_fail_when_mixing_special_names_and_numeric_locations() {
  Trace_file = "convert_names_does_not_fail_when_mixing_special_names_and_numeric_locations";
  Scenario_testing_scenario = true;
  Hide_errors = true;
  run("recipe main [\n  screen:number <- copy 1:number\n]\n");
  CHECK_TRACE_DOESNT_CONTAIN("error: mixing variable names and numeric addresses in main");
  CHECK_TRACE_COUNT("error", 0);
}
void check_screen(const string& expected_contents, const int color) {
  assert(!current_call().default_space);  // not supported
  long long int screen_location = get_or_insert(Memory, SCREEN)+/*skip refcount*/1;
  int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", "");
  assert(data_offset >= 0);
  long long int screen_data_location = screen_location+data_offset;  // type: address:shared:array:character
  long long int screen_data_start = get_or_insert(Memory, screen_data_location) + /*skip refcount*/1;  // type: array:character
  int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", "");
  long long int screen_width = get_or_insert(Memory, screen_location+width_offset);
  int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", "");
  long long int screen_height = get_or_insert(Memory, screen_location+height_offset);
  raw_string_stream cursor(expected_contents);
  // todo: too-long expected_contents should fail
  long long int addr = screen_data_start+/*skip length*/1;
  for (long long int row = 0; row < screen_height; ++row) {
    cursor.skip_whitespace_and_comments();
    if (cursor.at_end()) break;
    assert(cursor.get() == '.');
    for (long long int column = 0;  column < screen_width;  ++column, addr+= /*size of screen-cell*/2) {
      const int cell_color_offset = 1;
      uint32_t curr = cursor.get();
      if (get_or_insert(Memory, addr) == 0 && isspace(curr)) continue;
      if (curr == ' ' && color != -1 && color != get_or_insert(Memory, addr+cell_color_offset)) {
        // filter out other colors
        continue;
      }
      if (get_or_insert(Memory, addr) != 0 && get_or_insert(Memory, addr) == curr) {
        if (color == -1 || color == get_or_insert(Memory, addr+cell_color_offset)) continue;
        // contents match but color is off
        if (Current_scenario && !Scenario_testing_scenario) {
          // genuine test in a mu file
          raise_error << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ", address " << addr << ", value " << no_scientific(get_or_insert(Memory, addr)) << ") to be in color " << color << " instead of " << no_scientific(get_or_insert(Memory, addr+cell_color_offset)) << "\n" << end();
        }
        else {
          // just testing check_screen
          raise_error << "expected screen location (" << row << ", " << column << ") to be in color " << color << " instead of " << no_scientific(get_or_insert(Memory, addr+cell_color_offset)) << '\n' << end();
        }
        if (!Scenario_testing_scenario) {
          Passed = false;
          ++Num_failures;
        }
        return;
      }

      // really a mismatch
      // can't print multi-byte unicode characters in errors just yet. not very useful for debugging anyway.
      char expected_pretty[10] = {0};
      if (curr < 256 && !iscntrl(curr)) {
        // " ('<curr>')"
        expected_pretty[0] = ' ', expected_pretty[1] = '(', expected_pretty[2] = '\'', expected_pretty[3] = static_cast<unsigned char>(curr), expected_pretty[4] = '\'', expected_pretty[5] = ')', expected_pretty[6] = '\0';
      }
      char actual_pretty[10] = {0};
      if (get_or_insert(Memory, addr) < 256 && !iscntrl(get_or_insert(Memory, addr))) {
        // " ('<curr>')"
        actual_pretty[0] = ' ', actual_pretty[1] = '(', actual_pretty[2] = '\'', actual_pretty[3] = static_cast<unsigned char>(get_or_insert(Memory, addr)), actual_pretty[4] = '\'', actual_pretty[5] = ')', actual_pretty[6] = '\0';
      }

      ostringstream color_phrase;
      if (color != -1) color_phrase << " in color " << color;
      if (Current_scenario && !Scenario_testing_scenario) {
        // genuine test in a mu file
        raise_error << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end();
        dump_screen();
      }
      else {
        // just testing check_screen
        raise_error << "expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end();
      }
      if (!Scenario_testing_scenario) {
        Passed = false;
        ++Num_failures;
      }
      return;
    }
    assert(cursor.get() == '.');
  }
  cursor.skip_whitespace_and_comments();
  assert(cursor.at_end());
}

raw_string_stream::raw_string_stream(const string& backing) :index(0), max(SIZE(backing)), buf(backing.c_str()) {}

bool raw_string_stream::at_end() const {
  if (index >= max) return true;
  if (tb_utf8_char_length(buf[index]) > max-index) {
    raise_error << "unicode string seems corrupted at index "<< index << " character " << static_cast<int>(buf[index]) << '\n' << end();
    return true;
  }
  return false;
}

uint32_t raw_string_stream::get() {
  assert(index < max);  // caller must check bounds before calling 'get'
  uint32_t result = 0;
  int length = tb_utf8_char_to_unicode(&result, &buf[index]);
  assert(length != TB_EOF);
  index += length;
  return result;
}

uint32_t raw_string_stream::peek() {
  assert(index < max);  // caller must check bounds before calling 'get'
  uint32_t result = 0;
  int length = tb_utf8_char_to_unicode(&result, &buf[index]);
  assert(length != TB_EOF);
  return result;
}

void raw_string_stream::skip_whitespace_and_comments() {
  while (!at_end()) {
    if (isspace(peek())) get();
    else if (peek() == '#') {
      // skip comment
      get();
      while (peek() != '\n') get();  // implicitly also handles CRLF
    }
    else break;
  }
}

void dump_screen() {
  assert(!current_call().default_space);  // not supported
  long long int screen_location = get_or_insert(Memory, SCREEN) + /*skip refcount*/1;
  int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", "");
  long long int screen_width = get_or_insert(Memory, screen_location+width_offset);
  int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", "");
  long long int screen_height = get_or_insert(Memory, screen_location+height_offset);
  int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", "");
  assert(data_offset >= 0);
  long long int screen_data_location = screen_location+data_offset;  // type: address:shared:array:character
  long long int screen_data_start = get_or_insert(Memory, screen_data_location) + /*skip refcount*/1;  // type: array:character
  assert(get_or_insert(Memory, screen_data_start) == screen_width*screen_height);
  long long int curr = screen_data_start+1;  // skip length
  for (long long int row = 0; row < screen_height; ++row) {
    cerr << '.';
    for (long long int col = 0; col < screen_width; ++col) {
      if (get_or_insert(Memory, curr))
        cerr << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr)));
      else
        cerr << ' ';
      curr += /*size of screen-cell*/2;
    }
    cerr << ".\n";
  }
}


void initialize_key_names() {
  Key["F1"] = TB_KEY_F1;
  Key["F2"] = TB_KEY_F2;
  Key["F3"] = TB_KEY_F3;
  Key["F4"] = TB_KEY_F4;
  Key["F5"] = TB_KEY_F5;
  Key["F6"] = TB_KEY_F6;
  Key["F7"] = TB_KEY_F7;
  Key["F8"] = TB_KEY_F8;
  Key["F9"] = TB_KEY_F9;
  Key["F10"] = TB_KEY_F10;
  Key["F11"] = TB_KEY_F11;
  Key["F12"] = TB_KEY_F12;
  Key["insert"] = TB_KEY_INSERT;
  Key["delete"] = TB_KEY_DELETE;
  Key["home"] = TB_KEY_HOME;
  Key["end"] = TB_KEY_END;
  Key["page-up"] = TB_KEY_PGUP;
  Key["page-down"] = TB_KEY_PGDN;
  Key["up-arrow"] = TB_KEY_ARROW_UP;
  Key["down-arrow"] = TB_KEY_ARROW_DOWN;
  Key["left-arrow"] = TB_KEY_ARROW_LEFT;
  Key["right-arrow"] = TB_KEY_ARROW_RIGHT;
  Key["ctrl-a"] = TB_KEY_CTRL_A;
  Key["ctrl-b"] = TB_KEY_CTRL_B;
  Key["ctrl-c"] = TB_KEY_CTRL_C;
  Key["ctrl-d"] = TB_KEY_CTRL_D;
  Key["ctrl-e"] = TB_KEY_CTRL_E;
  Key["ctrl-f"] = TB_KEY_CTRL_F;
  Key["ctrl-g"] = TB_KEY_CTRL_G;
  Key["backspace"] = TB_KEY_BACKSPACE;
  Key["ctrl-h"] = TB_KEY_CTRL_H;
  Key["tab"] = TB_KEY_TAB;
  Key["ctrl-i"] = TB_KEY_CTRL_I;
  Key["ctrl-j"] = TB_KEY_CTRL_J;
  Key["enter"] = TB_KEY_NEWLINE;  // ignore CR/LF distinction; there is only 'enter'
  Key["ctrl-k"] = TB_KEY_CTRL_K;
  Key["ctrl-l"] = TB_KEY_CTRL_L;
  Key["ctrl-m"] = TB_KEY_CTRL_M;
  Key["ctrl-n"] = TB_KEY_CTRL_N;
  Key["ctrl-o"] = TB_KEY_CTRL_O;
  Key["ctrl-p"] = TB_KEY_CTRL_P;
  Key["ctrl-q"] = TB_KEY_CTRL_Q;
  Key["ctrl-r"] = TB_KEY_CTRL_R;
  Key["ctrl-s"] = TB_KEY_CTRL_S;
  Key["ctrl-t"] = TB_KEY_CTRL_T;
  Key["ctrl-u"] = TB_KEY_CTRL_U;
  Key["ctrl-v"] = TB_KEY_CTRL_V;
  Key["ctrl-w"] = TB_KEY_CTRL_W;
  Key["ctrl-x"] = TB_KEY_CTRL_X;
  Key["ctrl-y"] = TB_KEY_CTRL_Y;
  Key["ctrl-z"] = TB_KEY_CTRL_Z;
  Key["escape"] = TB_KEY_ESC;
}

long long int count_events(const recipe& r) {
  long long int result = 0;
  for (long long int i = 0; i < SIZE(r.steps); ++i) {
    const instruction& curr = r.steps.at(i);
    if (curr.name == "type")
      result += unicode_length(curr.ingredients.at(0).name);
    else
      result++;
  }
  return result;
}

long long int size_of_event() {
  // memoize result if already computed
  static long long int result = 0;
  if (result) return result;
  type_tree* type = new type_tree("event", get(Type_ordinal, "event"));
  result = size_of(type);
  delete type;
  return result;
}

long long int size_of_console() {
  // memoize result if already computed
  static long long int result = 0;
  if (result) return result;
  assert(get(Type_ordinal, "console"));
  type_tree* type = new type_tree("console", get(Type_ordinal, "console"));
  result = size_of(type)+/*refcount*/1;
  delete type;
  return result;
}


void start_trace_browser() {
  if (!Trace_stream) return;
  cerr << "computing min depth to display\n";
  long long int min_depth = 9999;
  for (long long int i = 0; i < SIZE(Trace_stream->past_lines); ++i) {
    trace_line& curr_line = Trace_stream->past_lines.at(i);
    if (curr_line.depth < min_depth) min_depth = curr_line.depth;
  }
  cerr << "min depth is " << min_depth << '\n';
  cerr << "computing lines to display\n";
  for (long long int i = 0; i < SIZE(Trace_stream->past_lines); ++i) {
    if (Trace_stream->past_lines.at(i).depth == min_depth)
      Visible.insert(i);
  }
  tb_init();
  Display_row = Display_column = 0;
  tb_event event;
  Top_of_screen = 0;
  refresh_screen_rows();
  while (true) {
    render();
    do {
      tb_poll_event(&event);
    } while (event.type != TB_EVENT_KEY);
    long long int key = event.key ? event.key : event.ch;
    if (key == 'q' || key == 'Q') break;
    if (key == 'j' || key == TB_KEY_ARROW_DOWN) {
      // move cursor one line down
      if (Display_row < Last_printed_row) ++Display_row;
    }
    if (key == 'k' || key == TB_KEY_ARROW_UP) {
      // move cursor one line up
      if (Display_row > 0) --Display_row;
    }
    if (key == 'H') {
      // move cursor to top of screen
      Display_row = 0;
    }
    if (key == 'M') {
      // move cursor to center of screen
      Display_row = tb_height()/2;
    }
    if (key == 'L') {
      // move cursor to bottom of screen
      Display_row = tb_height()-1;
    }
    if (key == 'J' || key == TB_KEY_PGDN) {
      // page-down
      if (Trace_index.find(tb_height()-1) != Trace_index.end()) {
        Top_of_screen = get(Trace_index, tb_height()-1) + 1;
        refresh_screen_rows();
      }
    }
    if (key == 'K' || key == TB_KEY_PGUP) {
      // page-up is more convoluted
      for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) {
        --Top_of_screen;
        if (Top_of_screen <= 0) break;
        while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen))
          --Top_of_screen;
      }
      if (Top_of_screen >= 0)
        refresh_screen_rows();
    }
    if (key == 'G') {
      // go to bottom of screen; largely like page-up, interestingly
      Top_of_screen = SIZE(Trace_stream->past_lines)-1;
      for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) {
        --Top_of_screen;
        if (Top_of_screen <= 0) break;
        while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen))
          --Top_of_screen;
      }
      refresh_screen_rows();
      // move cursor to bottom
      Display_row = Last_printed_row;
      refresh_screen_rows();
    }
    if (key == TB_KEY_CARRIAGE_RETURN) {
      // expand lines under current by one level
      assert(contains_key(Trace_index, Display_row));
      long long int start_index = get(Trace_index, Display_row);
      long long int index = 0;
      // simultaneously compute end_index and min_depth
      int min_depth = 9999;
      for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) {
        if (contains_key(Visible, index)) break;
        trace_line& curr_line = Trace_stream->past_lines.at(index);
        assert(curr_line.depth > Trace_stream->past_lines.at(start_index).depth);
        if (curr_line.depth < min_depth) min_depth = curr_line.depth;
      }
      long long int end_index = index;
      // mark as visible all intervening indices at min_depth
      for (index = start_index; index < end_index; ++index) {
        trace_line& curr_line = Trace_stream->past_lines.at(index);
        if (curr_line.depth == min_depth) {
          Visible.insert(index);
        }
      }
      refresh_screen_rows();
    }
    if (key == TB_KEY_BACKSPACE || key == TB_KEY_BACKSPACE2) {
      // collapse all lines under current
      assert(contains_key(Trace_index, Display_row));
      long long int start_index = get(Trace_index, Display_row);
      long long int index = 0;
      // end_index is the next line at a depth same as or lower than start_index
      int initial_depth = Trace_stream->past_lines.at(start_index).depth;
      for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) {
        if (!contains_key(Visible, index)) continue;
        trace_line& curr_line = Trace_stream->past_lines.at(index);
        if (curr_line.depth <= initial_depth) break;
      }
      long long int end_index = index;
      // mark as visible all intervening indices at min_depth
      for (index = start_index+1; index < end_index; ++index) {
        Visible.erase(index);
      }
      refresh_screen_rows();
    }
  }
  tb_shutdown();
}

// update Trace_indices for each screen_row on the basis of Top_of_screen and Visible
void refresh_screen_rows() {
  long long int screen_row = 0, index = 0;
  Trace_index.clear();
  for (screen_row = 0, index = Top_of_screen; screen_row < tb_height() && index < SIZE(Trace_stream->past_lines); ++screen_row, ++index) {
    // skip lines without depth for now
    while (!contains_key(Visible, index)) {
      ++index;
      if (index >= SIZE(Trace_stream->past_lines)) goto done;
    }
    assert(index < SIZE(Trace_stream->past_lines));
    put(Trace_index, screen_row, index);
  }
done:;
}

void render() {
  long long int screen_row = 0;
  for (screen_row = 0; screen_row < tb_height(); ++screen_row) {
    if (!contains_key(Trace_index, screen_row)) break;
    trace_line& curr_line = Trace_stream->past_lines.at(get(Trace_index, screen_row));
    ostringstream out;
    out << std::setw(4) << curr_line.depth << ' ' << curr_line.label << ": " << curr_line.contents;
    if (screen_row < tb_height()-1) {
      long long int delta = lines_hidden(screen_row);
      // home-brew escape sequence for red
      if (delta > 999) out << "{";
      out << " (" << delta << ")";
      if (delta > 999) out << "}";
    }
    render_line(screen_row, out.str());
  }
  // clear rest of screen
  Last_printed_row = screen_row-1;
  for (; screen_row < tb_height(); ++screen_row) {
    render_line(screen_row, "~");
  }
  // move cursor back to display row at the end
  tb_set_cursor(0, Display_row);
  tb_present();
}

long long int lines_hidden(long long int screen_row) {
  assert(contains_key(Trace_index, screen_row));
  if (!contains_key(Trace_index, screen_row+1))
    return SIZE(Trace_stream->past_lines) - get(Trace_index, screen_row);
  else
    return get(Trace_index, screen_row+1) - get(Trace_index, screen_row);
}

void render_line(int screen_row, const string& s) {
  long long int col = 0;
  int color = TB_WHITE;
  for (col = 0; col < tb_width() && col < SIZE(s); ++col) {
    char c = s.at(col);  // todo: unicode
    if (c == '\n') c = ';';  // replace newlines with semi-colons
    // escapes. hack: can't start a line with them.
    if (c == '{') { color = /*red*/1; c = ' '; }
    if (c == '}') { color = TB_WHITE; c = ' '; }
    tb_change_cell(col, screen_row, c, color, TB_BLACK);
  }
  for (; col < tb_width(); ++col) {
    tb_change_cell(col, screen_row, ' ', TB_WHITE, TB_BLACK);
  }
}

void load_trace(const char* filename) {
  ifstream tin(filename);
  if (!tin) {
    cerr << "no such file: " << filename << '\n';
    exit(1);
  }
  Trace_stream = new trace_stream;
  while (has_data(tin)) {
    tin >> std::noskipws;
      skip_whitespace_but_not_newline(tin);
      if (!isdigit(tin.peek())) {
        string dummy;
        getline(tin, dummy);
        continue;
      }
    tin >> std::skipws;
    int depth;
    tin >> depth;
    string label;
    tin >> label;
    if (*--label.end() == ':') label.erase(--label.end());
    string line;
    getline(tin, line);
    Trace_stream->past_lines.push_back(trace_line(depth, label, line));
  }
  cerr << "lines read: " << Trace_stream->past_lines.size() << '\n';
}


void test_run_interactive_code() {
  Trace_file = "run_interactive_code";
  run("recipe main [\n  1:number/raw <- copy 0\n  2:address:shared:array:character <- new [1:number/raw <- copy 34]\n  run-interactive 2:address:shared:array:character\n  3:number/raw <- copy 1:number/raw\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 3");
}
void test_run_interactive_empty() {
  Trace_file = "run_interactive_empty";
  run("recipe main [\n  1:address:shared:array:character <- copy 0/unsafe\n  2:address:shared:array:character <- run-interactive 1:address:shared:array:character\n]\n# result is null\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 2");
}
// reads a string, tries to call it as code (treating it as a test), saving
// all warnings.
// returns true if successfully called (no errors found during load and transform)
bool run_interactive(long long int address) {
  assert(contains_key(Recipe_ordinal, "interactive") && get(Recipe_ordinal, "interactive") != 0);
  // try to sandbox the run as best you can
  // todo: test this
  if (!Current_scenario) {
    for (long long int i = 1; i < Reserved_for_tests; ++i)
      Memory.erase(i);
  }
  string command = trim(strip_comments(read_mu_string(address)));
  if (command.empty()) return false;
  Name[get(Recipe_ordinal, "interactive")].clear();
  run_code_begin(/*snapshot_recently_added_recipes*/true);
  // don't kill the current routine on parse errors
  routine* save_current_routine = Current_routine;
  Current_routine = NULL;
  // call run(string) but without the scheduling
  load(string("recipe! interactive [\n") +
          "local-scope\n" +
          "screen:address:shared:screen <- next-ingredient\n" +
          "$start-tracking-products\n" +
          command + "\n" +
          "$stop-tracking-products\n" +
          "reply screen\n" +
       "]\n");
  transform_all();
  Current_routine = save_current_routine;
  if (trace_count("error") > 0) return false;
  // now call 'sandbox' which will run 'interactive' in a separate routine,
  // and wait for it
  if (Save_trace_stream) {
    ++Save_trace_stream->callstack_depth;
    trace(9999, "trace") << "run-interactive: incrementing callstack depth to " << Save_trace_stream->callstack_depth << end();
    assert(Save_trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
  }
  Current_routine->calls.push_front(call(get(Recipe_ordinal, "sandbox")));
  return true;
}

void run_code_begin(bool snapshot_recently_added_recipes) {
//?   cerr << "loading new trace\n";
  // stuff to undo later, in run_code_end()
  Hide_warnings = true;
  Hide_errors = true;
  Disable_redefine_warnings = true;
  if (snapshot_recently_added_recipes) {
    Save_recently_added_recipes = Recently_added_recipes;
    Recently_added_recipes.clear();
    Save_recently_added_shape_shifting_recipes = Recently_added_shape_shifting_recipes;
    Recently_added_shape_shifting_recipes.clear();
  }
  Save_trace_stream = Trace_stream;
  Save_trace_file = Trace_file;
  Trace_file = "";
  Trace_stream = new trace_stream;
  Trace_stream->collect_depth = App_depth;
}

void run_code_end() {
//?   cerr << "back to old trace\n";
  Hide_warnings = false;
  Hide_errors = false;
  Disable_redefine_warnings = false;
  delete Trace_stream;
  Trace_stream = Save_trace_stream;
  Save_trace_stream = NULL;
  Trace_file = Save_trace_file;
  Save_trace_file.clear();
  Recipe.erase(get(Recipe_ordinal, "interactive"));  // keep past sandboxes from inserting errors
  if (!Save_recently_added_recipes.empty()) {
    clear_recently_added_recipes();
    Recently_added_recipes = Save_recently_added_recipes;
    Save_recently_added_recipes.clear();
    Recently_added_shape_shifting_recipes = Save_recently_added_shape_shifting_recipes;
    Save_recently_added_shape_shifting_recipes.clear();
  }
}

void test_run_interactive_comments() {
  Trace_file = "run_interactive_comments";
  run("recipe main [\n  1:address:shared:array:character <- new [# ab\nadd 2, 2]\n  2:address:shared:array:character <- run-interactive 1:address:shared:array:character\n  3:array:character <- copy *2:address:shared:array:character\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 52 in location 4");
}
void test_run_interactive_converts_result_to_text() {
  Trace_file = "run_interactive_converts_result_to_text";
  run("recipe main [\n  # try to interactively add 2 and 2\n  1:address:shared:array:character <- new [add 2, 2]\n  2:address:shared:array:character <- run-interactive 1:address:shared:array:character\n  10:array:character <- copy 2:address:shared:array:character/lookup\n]\n# first letter in the output should be '4' in unicode\n");
  CHECK_TRACE_CONTENTS("mem: storing 52 in location 11");
}
void test_run_interactive_returns_text() {
  Trace_file = "run_interactive_returns_text";
  run("recipe main [\n  # try to interactively add 2 and 2\n  1:address:shared:array:character <- new [\n    x:address:shared:array:character <- new [a]\n    y:address:shared:array:character <- new [b]\n    z:address:shared:array:character <- append x:address:shared:array:character, y:address:shared:array:character\n  ]\n  2:address:shared:array:character <- run-interactive 1:address:shared:array:character\n  10:array:character <- copy 2:address:shared:array:character/lookup\n]\n# output contains \"ab\"\n");
  CHECK_TRACE_CONTENTS("mem: storing 97 in location 11mem: storing 98 in location 12");
}
void test_run_interactive_returns_errors() {
  Trace_file = "run_interactive_returns_errors";
  run("recipe main [\n  # run a command that generates an error\n  1:address:shared:array:character <- new [x:number <- copy 34\nget x:number, foo:offset]\n  2:address:shared:array:character, 3:address:shared:array:character <- run-interactive 1:address:shared:array:character\n  10:array:character <- copy 3:address:shared:array:character/lookup\n]\n# error should be \"unknown element foo in container number\"\n");
  CHECK_TRACE_CONTENTS("mem: storing 117 in location 11mem: storing 110 in location 12mem: storing 107 in location 13mem: storing 110 in location 14");
}
void test_run_interactive_with_comment() {
  Trace_file = "run_interactive_with_comment";
  run("recipe main [\n  # 2 instructions, with a comment after the first\n  1:address:shared:array:number <- new [a:number <- copy 0  # abc\nb:number <- copy 0\n]\n  2:address:shared:array:character, 3:address:shared:array:character <- run-interactive 1:address:shared:array:character\n]\n# no errors\n");
  CHECK_TRACE_CONTENTS("mem: storing 0 in location 3");
}
void test_run_interactive_cleans_up_any_created_specializations() {
  // define a generic recipe
  assert(!contains_key(Recipe_ordinal, "foo"));
  load("recipe foo x:_elem -> n:number [\n"
       "  reply 34\n"
       "]\n");
  assert(SIZE(Recently_added_recipes) == 1);  // foo
  assert(variant_count("foo") == 1);
  // run-interactive a call that specializes this recipe
  run("recipe main [\n"
       "  1:number/raw <- copy 0\n"
       "  2:address:shared:array:character <- new [foo 1:number/raw]\n"
       "  run-interactive 2:address:shared:array:character\n"
       "]\n");
  assert(SIZE(Recently_added_recipes) == 2);  // foo, main
  // check that number of variants doesn't change
  CHECK_EQ(variant_count("foo"), 1);
}

long long int variant_count(string recipe_name) {
  if (!contains_key(Recipe_variants, recipe_name)) return 0;
  return non_ghost_size(get(Recipe_variants, recipe_name));
}

void track_most_recent_products(const instruction& instruction, const vector<vector<double> >& products) {
  ostringstream out;
  for (long long int i = 0; i < SIZE(products); ++i) {
    // string
    if (i < SIZE(instruction.products)) {
      if (is_mu_string(instruction.products.at(i))) {
        if (!scalar(products.at(i))) {
          tb_shutdown();
          cerr << read_mu_string(trace_error_warning_contents()) << '\n';
          cerr << SIZE(products.at(i)) << ": ";
          for (long long int j = 0; j < SIZE(products.at(i)); ++j)
            cerr << no_scientific(products.at(i).at(j)) << ' ';
          cerr << '\n';
        }
        assert(scalar(products.at(i)));
        out << read_mu_string(products.at(i).at(0)) << '\n';
        continue;
      }
      // End Record Product Special-cases
    }
    for (long long int j = 0; j < SIZE(products.at(i)); ++j)
      out << no_scientific(products.at(i).at(j)) << ' ';
    out << '\n';
  }
  Most_recent_products = out.str();
}

string strip_comments(string in) {
  ostringstream result;
  for (long long int i = 0; i < SIZE(in); ++i) {
    if (in.at(i) != '#') {
      result << in.at(i);
    }
    else {
      while (i+1 < SIZE(in) && in.at(i+1) != '\n')
        ++i;
    }
  }
  return result.str();
}

long long int stringified_value_of_location(long long int address) {
  // convert to string
  ostringstream out;
  out << no_scientific(get_or_insert(Memory, address));
  return new_mu_string(out.str());
}

long long int trace_error_warning_contents() {
  if (!Trace_stream) return 0;
  ostringstream out;
  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    if (p->depth > Warning_depth) continue;
    out << p->contents;
    if (*--p->contents.end() != '\n') out << '\n';
  }
  string result = out.str();
  if (result.empty()) return 0;
  truncate(result);
  return new_mu_string(result);
}

long long int trace_app_contents() {
  if (!Trace_stream) return 0;
  ostringstream out;
  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) {
    if (p->depth != App_depth) continue;
    out << p->contents;
    if (*--p->contents.end() != '\n') out << '\n';
  }
  string result = out.str();
  if (result.empty()) return 0;
  truncate(result);
  return new_mu_string(result);
}

void truncate(string& x) {
  if (SIZE(x) > 512) {
    x.erase(512);
    *x.rbegin() = '\n';
    *++x.rbegin() = '.';
    *++++x.rbegin() = '.';
  }
}


void test_reload_continues_past_error() {
  Trace_file = "reload_continues_past_error";
  run("recipe main [\n  local-scope\n  x:address:shared:array:character <- new [recipe foo [\n  get 1234:number, foo:offset\n]]\n  reload x\n  1:number/raw <- copy 34\n]\n");
  CHECK_TRACE_CONTENTS("mem: storing 34 in location 1");
}
void test_reload_cleans_up_any_created_specializations() {
  // define a generic recipe and a call to it
  assert(!contains_key(Recipe_ordinal, "foo"));
  assert(variant_count("foo") == 0);
  // a call that specializes this recipe
  run("recipe main [\n"
      "  local-scope\n"
      "  x:address:shared:array:character <- new [recipe foo x:_elem -> n:number [\n"
      "local-scope\n"
      "load-ingredients\n"
      "reply 34\n"
      "]\n"
      "recipe main2 [\n"
      "local-scope\n"
      "load-ingredients\n"
      "x:number <- copy 34\n"
      "foo x:number\n"
      "]]\n"
      "  reload x\n"
      "]\n");
  // check that number of variants includes specialization
  assert(SIZE(Recently_added_recipes) == 4);  // foo, main, main2, foo specialization
  CHECK_EQ(variant_count("foo"), 2);
}


string slurp(const string& filename) {
  ostringstream result;
  ifstream fin(filename.c_str());
  fin.peek();
  if (!fin) return result.str();  // don't bother checking errno
  const int N = 1024;
  char buf[N];
  while (has_data(fin)) {
    bzero(buf, N);
    fin.read(buf, N-1);  // leave at least one null
    result << buf;
  }
  fin.close();
  return result.str();
}

bool exists(const string& filename) {
  struct stat dummy;
  return 0 == stat(filename.c_str(), &dummy);
}

//? :(before "End Transform All")
//? check_type_pointers();
//? 
//? :(code)
//? void check_type_pointers() {
//?   for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
//?     if (any_type_ingredient_in_header(p->first)) continue;
//?     const recipe& r = p->second;
//?     for (long long int i = 0; i < SIZE(r.steps); ++i) {
//?       const instruction& inst = r.steps.at(i);
//?       for (long long int j = 0; j < SIZE(inst.ingredients); ++j) {
//?         if (!inst.ingredients.at(j).type) {
//?           raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.ingredients.at(j).to_string() << " has no type\n" << end();
//?           return;
//?         }
//?         if (!inst.ingredients.at(j).properties.at(0).second) {
//?           raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.ingredients.at(j).to_string() << " has no type name\n" << end();
//?           return;
//?         }
//?       }
//?       for (long long int j = 0; j < SIZE(inst.products); ++j) {
//?         if (!inst.products.at(j).type) {
//?           raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.products.at(j).to_string() << " has no type\n" << end();
//?           return;
//?         }
//?         if (!inst.products.at(j).properties.at(0).second) {
//?           raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.products.at(j).to_string() << " has no type name\n" << end();
//?           return;
//?         }
//?       }
//?     }
//?   }
//? }