about summary refs log tree commit diff stats
path: root/install-all.sh
blob: e545dd380e1b2b2dde0166dfb848f1bf396c3a19 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
#!/bin/bash

set -o errtrace

STATUS=development

error_handler()
{
        ERR_CODE=$?
        echo "Error $ERR_CODE with command '$BASH_COMMAND' on line ${BASH_LINENO[0]}. Exiting."
        exit $ERR_CODE

}

trap error_handler ERR

debian_prepare()
{
    echo
    echo Profanity installer ... updating apt repositories
    echo
    sudo apt-get update

    echo
    echo Profanity installer... installing dependencies
    echo
    sudo apt-get -y install git automake autoconf libssl-dev libexpat1-dev libncursesw5-dev libglib2.0-dev libnotify-dev libcurl3-dev libxss-dev libotr5-dev libreadline-dev libtool libgpgme11-dev

}

fedora_prepare()
{
    echo
    echo Profanity installer... installing dependencies
    echo

    sudo dnf -y install gcc git autoconf automake openssl-devel expat-devel ncurses-devel glib2-devel libnotify-devel libcurl-devel libXScrnSaver-devel libotr3-devel readline-devel libtool gpgme-devel
}

opensuse_prepare()
{
    echo
    echo Profanity installer...installing dependencies
    echo
    sudo zypper -n in gcc git automake make autoconf libopenssl-devel expat libexpat-devel ncurses-devel glib2-devel libnotify-devel libcurl-devel libXScrnSaver-devel libotr-devel readline-devel libtool libgpgme-devel
}

centos_prepare()
{
    echo
    echo Profanity installer...installing dependencies
    echo

    sudo yum -y install epel-release
    sudo yum -y install git
    sudo yum -y install gcc autoconf automake cmake
    sudo yum -y install openssl-devel expat-devel ncurses-devel glib2-devel libnotify-devel libcurl-devel libXScrnSaver-devel libotr-devel readline-devel libtool gpgme-devel
}

cygwin_prepare()
{
    echo
    echo Profanity installer... installing dependencies
    echo

    if ! command -v apt-cyg &>/dev/null; then cyg_install_apt_cyg; fi
    if [ -n "$CYG_MIRROR" ]; then
        apt-cyg -m $CYG_MIRROR install git make gcc-core m4 automake autoconf pkg-config openssl-devel libexpat-devel zlib-devel libncursesw-devel libglib2.0-devel libcurl-devel libidn-devel libssh2-devel libkrb5-devel openldap-devel libgcrypt-devel libreadline-devel libgpgme-devel libtool
    else
        apt-cyg install git make gcc-core m4 automake autoconf pkg-config openssl-devel libexpat-devel zlib-devel libncursesw-devel libglib2.0-devel libcurl-devel libidn-devel libssh2-devel libkrb5-devel openldap-devel libgcrypt-devel libreadline-devel libgpgme-devel libtool

    fi
}

install_lib_mesode()
{
    echo
    echo Profanity installer... installing libmesode
    echo
    git clone https://github.com/boothj5/libmesode.git
    cd libmesode
    ./bootstrap.sh
    ./configure --prefix=$1
    make
    sudo make install

    cd ..
}

install_profanity()
{
    echo
    echo Profanity installer... installing Profanity
    echo
    if [ "${STATUS}" = "development" ]; then
        ./bootstrap.sh
    fi
    ./configure
    make
    sudo make install
}

cyg_install_apt_cyg()
{
    echo
    echo Profanity installer... installing apt-cyg
    echo
    wget https://raw.githubusercontent.com/transcode-open/apt-cyg/master/apt-cyg
    #wget --no-check-certificate https://raw.github.com/boothj5/apt-cyg/master/apt-cyg
    #wget http://apt-cyg.googlecode.com/svn/trunk/apt-cyg
    chmod +x apt-cyg
    mv apt-cyg /usr/local/bin/

}
cyg_install_lib_mesode()
{
    echo
    echo Profanity installer... installing libmesode
    echo
    git clone https://github.com/boothj5/libmesode.git
    cd libmesode
    ./bootstrap.sh
    ./bootstrap.sh # second call seems to fix problem on cygwin
    ./configure --prefix=/usr
    make
    make install

    cd ..
}

cyg_install_profanity()
{
    echo
    echo Profanity installer... installing Profanity
    echo
    if [ "${STATUS}" = "development" ]; then
        ./bootstrap.sh
    fi
    ./configure
    make
    make install
}

cleanup()
{
    echo
    echo Profanity installer... cleaning up
    echo

    echo Removing libmesode repository...
    rm -rf libmesode

    echo
    echo Profanity installer... complete!
    echo
    echo Type \'profanity\' to run.
    echo
}

while getopts m: opt
do
    case "$opt" in
        m) CYG_MIRROR=$OPTARG;;
    esac
done

OS=`uname -s`
DIST=unknown

if [ "${OS}" = "Linux" ]; then
    if [ -f /etc/fedora-release ]; then
        DIST=fedora
    elif [ -f /etc/debian_version ]; then
        DIST=debian
    elif [pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char
color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 022arithmetic.cc</title>
<meta name="Generator" content="Vim/8.0">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="cpp">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #aaaaaa; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #aaaaaa; background-color: #080808; }
a { color:#eeeeee; text-decoration: none; }
a:hover { text-decoration: underline; }
* { font-size: 12pt; font-size: 1em; }
.traceContains { color: #008000; }
.LineNr { color: #444444; }
.Constant { color: #00a0a0; }
.muRecipe { color: #ff8700; }
.Delimiter { color: #800080; }
.Special { color: #c00000; }
.Identifier { color: #c0a020; }
.Normal { color: #aaaaaa; background-color: #080808; padding-bottom: 1px; }
.Comment { color: #9090ff; }
.Comment a { color:#0000ee; text-decoration:underline; }
.cSpecial { color: #008000; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="Comment">//: Arithmetic primitives</span>
<span id="L2" class="LineNr">  2 </span>
<span id="L3" class="LineNr">  3 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L4" class="LineNr">  4 </span>ADD<span class="Delimiter">,</span>
<span id="L5" class="LineNr">  5 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L6" class="LineNr">  6 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;add&quot;</span><span class="Delimiter">,</span> ADD<span class="Delimiter">);</span>
<span id="L7" class="LineNr">  7 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L8" class="LineNr">  8 </span><span class="Normal">case</span> ADD: <span class="Delimiter">{</span>
<span id="L9" class="LineNr">  9 </span>  <span class="Comment">// primary goal of these checks is to forbid address arithmetic</span>
<span id="L10" class="LineNr"> 10 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L11" class="LineNr"> 11 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L12" class="LineNr"> 12 </span>      <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'add' requires number ingredients, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L13" class="LineNr"> 13 </span>      <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L14" class="LineNr"> 14 </span>    <span class="Delimiter">}</span>
<span id="L15" class="LineNr"> 15 </span>  <span class="Delimiter">}</span>
<span id="L16" class="LineNr"> 16 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L17" class="LineNr"> 17 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'add' yields exactly one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L18" class="LineNr"> 18 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L19" class="LineNr"> 19 </span>  <span class="Delimiter">}</span>
<span id="L20" class="LineNr"> 20 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L21" class="LineNr"> 21 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'add' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L22" class="LineNr"> 22 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L23" class="LineNr"> 23 </span>  <span class="Delimiter">}</span>
<span id="L24" class="LineNr"> 24 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L25" class="LineNr"> 25 </span><span class="Delimiter">}</span>
<span id="L26" class="LineNr"> 26 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L27" class="LineNr"> 27 </span><span class="Normal">case</span> ADD: <span class="Delimiter">{</span>
<span id="L28" class="LineNr"> 28 </span>  <span class="Normal">double</span> result = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L29" class="LineNr"> 29 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L30" class="LineNr"> 30 </span>    result += ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L31" class="LineNr"> 31 </span>  <span class="Delimiter">}</span>
<span id="L32" class="LineNr"> 32 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L33" class="LineNr"> 33 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L34" class="LineNr"> 34 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L35" class="LineNr"> 35 </span><span class="Delimiter">}</span>
<span id="L36" class="LineNr"> 36 </span>
<span id="L37" class="LineNr"> 37 </span><span class="Delimiter">:(scenario add_literal)</span>
<span id="L38" class="LineNr"> 38 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L39" class="LineNr"> 39 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">23</span><span class="Delimiter">,</span> <span class="Constant">34</span>
<span id="L40" class="LineNr"> 40 </span>]
<span id="L41" class="LineNr"> 41 </span><span class="traceContains">+mem: storing 57 in location 1</span>
<span id="L42" class="LineNr"> 42 </span>
<span id="L43" class="LineNr"> 43 </span><span class="Delimiter">:(scenario add)</span>
<span id="L44" class="LineNr"> 44 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L45" class="LineNr"> 45 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
<span id="L46" class="LineNr"> 46 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L47" class="LineNr"> 47 </span>  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L48" class="LineNr"> 48 </span>]
<span id="L49" class="LineNr"> 49 </span><span class="traceContains">+mem: storing 57 in location 3</span>
<span id="L50" class="LineNr"> 50 </span>
<span id="L51" class="LineNr"> 51 </span><span class="Delimiter">:(scenario add_multiple)</span>
<span id="L52" class="LineNr"> 52 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L53" class="LineNr"> 53 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
<span id="L54" class="LineNr"> 54 </span>]
<span id="L55" class="LineNr"> 55 </span><span class="traceContains">+mem: storing 12 in location 1</span>
<span id="L56" class="LineNr"> 56 </span>
<span id="L57" class="LineNr"> 57 </span><span class="Delimiter">:(scenario add_checks_type)</span>
<span id="L58" class="LineNr"> 58 </span><span class="Special">% Hide_errors = true;</span>
<span id="L59" class="LineNr"> 59 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L60" class="LineNr"> 60 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>add <span class="Constant">2</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L61" class="LineNr"> 61 </span>]
<span id="L62" class="LineNr"> 62 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: 'add' requires number ingredients, but got '2:bool'</span>
<span id="L63" class="LineNr"> 63 </span>
<span id="L64" class="LineNr"> 64 </span><span class="Delimiter">:(scenario add_checks_return_type)</span>
<span id="L65" class="LineNr"> 65 </span><span class="Special">% Hide_errors = true;</span>
<span id="L66" class="LineNr"> 66 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L67" class="LineNr"> 67 </span>  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>add <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L68" class="LineNr"> 68 </span>]
<span id="L69" class="LineNr"> 69 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: 'add' should yield a number, but got '1:&amp;:num'</span>
<span id="L70" class="LineNr"> 70 </span>
<span id="L71" class="LineNr"> 71 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L72" class="LineNr"> 72 </span>SUBTRACT<span class="Delimiter">,</span>
<span id="L73" class="LineNr"> 73 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L74" class="LineNr"> 74 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;subtract&quot;</span><span class="Delimiter">,</span> SUBTRACT<span class="Delimiter">);</span>
<span id="L75" class="LineNr"> 75 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L76" class="LineNr"> 76 </span><span class="Normal">case</span> SUBTRACT: <span class="Delimiter">{</span>
<span id="L77" class="LineNr"> 77 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L78" class="LineNr"> 78 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'subtract' has no ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L79" class="LineNr"> 79 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L80" class="LineNr"> 80 </span>  <span class="Delimiter">}</span>
<span id="L81" class="LineNr"> 81 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L82" class="LineNr"> 82 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L83" class="LineNr"> 83 </span>      <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'subtract' requires number ingredients, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L84" class="LineNr"> 84 </span>      <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L85" class="LineNr"> 85 </span>    <span class="Delimiter">}</span>
<span id="L86" class="LineNr"> 86 </span>  <span class="Delimiter">}</span>
<span id="L87" class="LineNr"> 87 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L88" class="LineNr"> 88 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'subtract' yields exactly one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L89" class="LineNr"> 89 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L90" class="LineNr"> 90 </span>  <span class="Delimiter">}</span>
<span id="L91" class="LineNr"> 91 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L92" class="LineNr"> 92 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'subtract' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L93" class="LineNr"> 93 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L94" class="LineNr"> 94 </span>  <span class="Delimiter">}</span>
<span id="L95" class="LineNr"> 95 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L96" class="LineNr"> 96 </span><span class="Delimiter">}</span>
<span id="L97" class="LineNr"> 97 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L98" class="LineNr"> 98 </span><span class="Normal">case</span> SUBTRACT: <span class="Delimiter">{</span>
<span id="L99" class="LineNr"> 99 </span>  <span class="Normal">double</span> result = ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L100" class="LineNr">100 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">1</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L101" class="LineNr">101 </span>    result -= ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L102" class="LineNr">102 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L103" class="LineNr">103 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L104" class="LineNr">104 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L105" class="LineNr">105 </span><span class="Delimiter">}</span>
<span id="L106" class="LineNr">106 </span>
<span id="L107" class="LineNr">107 </span><span class="Delimiter">:(scenario subtract_literal)</span>
<span id="L108" class="LineNr">108 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L109" class="LineNr">109 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">5</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L110" class="LineNr">110 </span>]
<span id="L111" class="LineNr">111 </span><span class="traceContains">+mem: storing 3 in location 1</span>
<span id="L112" class="LineNr">112 </span>
<span id="L113" class="LineNr">113 </span><span class="Delimiter">:(scenario subtract)</span>
<span id="L114" class="LineNr">114 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L115" class="LineNr">115 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
<span id="L116" class="LineNr">116 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L117" class="LineNr">117 </span>  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L118" class="LineNr">118 </span>]
<span id="L119" class="LineNr">119 </span><span class="traceContains">+mem: storing -11 in location 3</span>
<span id="L120" class="LineNr">120 </span>
<span id="L121" class="LineNr">121 </span><span class="Delimiter">:(scenario subtract_multiple)</span>
<span id="L122" class="LineNr">122 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L123" class="LineNr">123 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">6</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L124" class="LineNr">124 </span>]
<span id="L125" class="LineNr">125 </span><span class="traceContains">+mem: storing 1 in location 1</span>
<span id="L126" class="LineNr">126 </span>
<span id="L127" class="LineNr">127 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L128" class="LineNr">128 </span>MULTIPLY<span class="Delimiter">,</span>
<span id="L129" class="LineNr">129 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L130" class="LineNr">130 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;multiply&quot;</span><span class="Delimiter">,</span> MULTIPLY<span class="Delimiter">);</span>
<span id="L131" class="LineNr">131 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L132" class="LineNr">132 </span><span class="Normal">case</span> MULTIPLY: <span class="Delimiter">{</span>
<span id="L133" class="LineNr">133 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L134" class="LineNr">134 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L135" class="LineNr">135 </span>      <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'multiply' requires number ingredients, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L136" class="LineNr">136 </span>      <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L137" class="LineNr">137 </span>    <span class="Delimiter">}</span>
<span id="L138" class="LineNr">138 </span>  <span class="Delimiter">}</span>
<span id="L139" class="LineNr">139 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L140" class="LineNr">140 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'multiply' yields exactly one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L141" class="LineNr">141 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L142" class="LineNr">142 </span>  <span class="Delimiter">}</span>
<span id="L143" class="LineNr">143 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L144" class="LineNr">144 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'multiply' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L145" class="LineNr">145 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L146" class="LineNr">146 </span>  <span class="Delimiter">}</span>
<span id="L147" class="LineNr">147 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L148" class="LineNr">148 </span><span class="Delimiter">}</span>
<span id="L149" class="LineNr">149 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L150" class="LineNr">150 </span><span class="Normal">case</span> MULTIPLY: <span class="Delimiter">{</span>
<span id="L151" class="LineNr">151 </span>  <span class="Normal">double</span> result = <span class="Constant">1</span><span class="Delimiter">;</span>
<span id="L152" class="LineNr">152 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L153" class="LineNr">153 </span>    result *= ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L154" class="LineNr">154 </span>  <span class="Delimiter">}</span>
<span id="L155" class="LineNr">155 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L156" class="LineNr">156 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L157" class="LineNr">157 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L158" class="LineNr">158 </span><span class="Delimiter">}</span>
<span id="L159" class="LineNr">159 </span>
<span id="L160" class="LineNr">160 </span><span class="Delimiter">:(scenario multiply_literal)</span>
<span id="L161" class="LineNr">161 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L162" class="LineNr">162 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">3</span>
<span id="L163" class="LineNr">163 </span>]
<span id="L164" class="LineNr">164 </span><span class="traceContains">+mem: storing 6 in location 1</span>
<span id="L165" class="LineNr">165 </span>
<span id="L166" class="LineNr">166 </span><span class="Delimiter">:(scenario multiply)</span>
<span id="L167" class="LineNr">167 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L168" class="LineNr">168 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">4</span>
<span id="L169" class="LineNr">169 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">6</span>
<span id="L170" class="LineNr">170 </span>  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L171" class="LineNr">171 </span>]
<span id="L172" class="LineNr">172 </span><span class="traceContains">+mem: storing 24 in location 3</span>
<span id="L173" class="LineNr">173 </span>
<span id="L174" class="LineNr">174 </span><span class="Delimiter">:(scenario multiply_multiple)</span>
<span id="L175" class="LineNr">175 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L176" class="LineNr">176 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
<span id="L177" class="LineNr">177 </span>]
<span id="L178" class="LineNr">178 </span><span class="traceContains">+mem: storing 24 in location 1</span>
<span id="L179" class="LineNr">179 </span>
<span id="L180" class="LineNr">180 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L181" class="LineNr">181 </span>DIVIDE<span class="Delimiter">,</span>
<span id="L182" class="LineNr">182 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L183" class="LineNr">183 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;divide&quot;</span><span class="Delimiter">,</span> DIVIDE<span class="Delimiter">);</span>
<span id="L184" class="LineNr">184 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L185" class="LineNr">185 </span><span class="Normal">case</span> DIVIDE: <span class="Delimiter">{</span>
<span id="L186" class="LineNr">186 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L187" class="LineNr">187 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide' has no ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L188" class="LineNr">188 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L189" class="LineNr">189 </span>  <span class="Delimiter">}</span>
<span id="L190" class="LineNr">190 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L191" class="LineNr">191 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L192" class="LineNr">192 </span>      <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide' requires number ingredients, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L193" class="LineNr">193 </span>      <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L194" class="LineNr">194 </span>    <span class="Delimiter">}</span>
<span id="L195" class="LineNr">195 </span>  <span class="Delimiter">}</span>
<span id="L196" class="LineNr">196 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L197" class="LineNr">197 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide' yields exactly one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L198" class="LineNr">198 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L199" class="LineNr">199 </span>  <span class="Delimiter">}</span>
<span id="L200" class="LineNr">200 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L201" class="LineNr">201 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L202" class="LineNr">202 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L203" class="LineNr">203 </span>  <span class="Delimiter">}</span>
<span id="L204" class="LineNr">204 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L205" class="LineNr">205 </span><span class="Delimiter">}</span>
<span id="L206" class="LineNr">206 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L207" class="LineNr">207 </span><span class="Normal">case</span> DIVIDE: <span class="Delimiter">{</span>
<span id="L208" class="LineNr">208 </span>  <span class="Normal">double</span> result = ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L209" class="LineNr">209 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">1</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L210" class="LineNr">210 </span>    result /= ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L211" class="LineNr">211 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L212" class="LineNr">212 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L213" class="LineNr">213 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L214" class="LineNr">214 </span><span class="Delimiter">}</span>
<span id="L215" class="LineNr">215 </span>
<span id="L216" class="LineNr">216 </span><span class="Delimiter">:(scenario divide_literal)</span>
<span id="L217" class="LineNr">217 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L218" class="LineNr">218 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">8</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L219" class="LineNr">219 </span>]
<span id="L220" class="LineNr">220 </span><span class="traceContains">+mem: storing 4 in location 1</span>
<span id="L221" class="LineNr">221 </span>
<span id="L222" class="LineNr">222 </span><span class="Delimiter">:(scenario divide)</span>
<span id="L223" class="LineNr">223 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L224" class="LineNr">224 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">27</span>
<span id="L225" class="LineNr">225 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
<span id="L226" class="LineNr">226 </span>  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L227" class="LineNr">227 </span>]
<span id="L228" class="LineNr">228 </span><span class="traceContains">+mem: storing 9 in location 3</span>
<span id="L229" class="LineNr">229 </span>
<span id="L230" class="LineNr">230 </span><span class="Delimiter">:(scenario divide_multiple)</span>
<span id="L231" class="LineNr">231 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L232" class="LineNr">232 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">12</span><span class="Delimiter">,</span> <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L233" class="LineNr">233 </span>]
<span id="L234" class="LineNr">234 </span><span class="traceContains">+mem: storing 2 in location 1</span>
<span id="L235" class="LineNr">235 </span>
<span id="L236" class="LineNr">236 </span><span class="Comment">//: Integer division</span>
<span id="L237" class="LineNr">237 </span>
<span id="L238" class="LineNr">238 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L239" class="LineNr">239 </span>DIVIDE_WITH_REMAINDER<span class="Delimiter">,</span>
<span id="L240" class="LineNr">240 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L241" class="LineNr">241 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;divide-with-remainder&quot;</span><span class="Delimiter">,</span> DIVIDE_WITH_REMAINDER<span class="Delimiter">);</span>
<span id="L242" class="LineNr">242 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L243" class="LineNr">243 </span><span class="Normal">case</span> DIVIDE_WITH_REMAINDER: <span class="Delimiter">{</span>
<span id="L244" class="LineNr">244 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L245" class="LineNr">245 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide-with-remainder' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L246" class="LineNr">246 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L247" class="LineNr">247 </span>  <span class="Delimiter">}</span>
<span id="L248" class="LineNr">248 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L249" class="LineNr">249 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide-with-remainder' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L250" class="LineNr">250 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L251" class="LineNr">251 </span>  <span class="Delimiter">}</span>
<span id="L252" class="LineNr">252 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L253" class="LineNr">253 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide-with-remainder' yields two products in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L254" class="LineNr">254 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L255" class="LineNr">255 </span>  <span class="Delimiter">}</span>
<span id="L256" class="LineNr">256 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L257" class="LineNr">257 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L258" class="LineNr">258 </span>      <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'divide-with-remainder' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L259" class="LineNr">259 </span>      <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L260" class="LineNr">260 </span>    <span class="Delimiter">}</span>
<span id="L261" class="LineNr">261 </span>  <span class="Delimiter">}</span>
<span id="L262" class="LineNr">262 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L263" class="LineNr">263 </span><span class="Delimiter">}</span>
<span id="L264" class="LineNr">264 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L265" class="LineNr">265 </span><span class="Normal">case</span> DIVIDE_WITH_REMAINDER: <span class="Delimiter">{</span>
<span id="L266" class="LineNr">266 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">2</span><span class="Delimiter">);</span>
<span id="L267" class="LineNr">267 </span>  <span class="Comment">// fractions will be dropped; very large numbers will overflow</span>
<span id="L268" class="LineNr">268 </span>  <span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L269" class="LineNr">269 </span>  <span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L270" class="LineNr">270 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>b == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L271" class="LineNr">271 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span><a href='026call.cc.html#L87'>current_recipe_name</a><span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;divide by zero in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>current_instruction<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L272" class="LineNr">272 </span>    products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">2</span><span class="Delimiter">);</span>
<span id="L273" class="LineNr">273 </span>    products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L274" class="LineNr">274 </span>    products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L275" class="LineNr">275 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L276" class="LineNr">276 </span>  <span class="Delimiter">}</span>
<span id="L277" class="LineNr">277 </span>  <span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span> quotient = a / b<span class="Delimiter">;</span>
<span id="L278" class="LineNr">278 </span>  <span class="Normal">long</span> <span class="Normal">long</span> <span class="Normal">int</span> remainder = a % b<span class="Delimiter">;</span>
<span id="L279" class="LineNr">279 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Normal">static_cast</span>&lt;<span class="Normal">double</span>&gt;<span class="Delimiter">(</span>quotient<span class="Delimiter">));</span>
<span id="L280" class="LineNr">280 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Normal">static_cast</span>&lt;<span class="Normal">double</span>&gt;<span class="Delimiter">(</span>remainder<span class="Delimiter">));</span>
<span id="L281" class="LineNr">281 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L282" class="LineNr">282 </span><span class="Delimiter">}</span>
<span id="L283" class="LineNr">283 </span>
<span id="L284" class="LineNr">284 </span><span class="Delimiter">:(scenario divide_with_remainder_literal)</span>
<span id="L285" class="LineNr">285 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L286" class="LineNr">286 </span>  <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">9</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L287" class="LineNr">287 </span>]
<span id="L288" class="LineNr">288 </span><span class="traceContains">+mem: storing 4 in location 1</span>
<span id="L289" class="LineNr">289 </span><span class="traceContains">+mem: storing 1 in location 2</span>
<span id="L290" class="LineNr">290 </span>
<span id="L291" class="LineNr">291 </span><span class="Delimiter">:(scenario divide_with_remainder)</span>
<span id="L292" class="LineNr">292 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L293" class="LineNr">293 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">27</span>
<span id="L294" class="LineNr">294 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">11</span>
<span id="L295" class="LineNr">295 </span>  <span class="Constant">3</span>:num<span class="Delimiter">,</span> <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L296" class="LineNr">296 </span>]
<span id="L297" class="LineNr">297 </span><span class="traceContains">+mem: storing 2 in location 3</span>
<span id="L298" class="LineNr">298 </span><span class="traceContains">+mem: storing 5 in location 4</span>
<span id="L299" class="LineNr">299 </span>
<span id="L300" class="LineNr">300 </span><span class="Delimiter">:(scenario divide_with_decimal_point)</span>
<span id="L301" class="LineNr">301 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L302" class="LineNr">302 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">5</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L303" class="LineNr">303 </span>]
<span id="L304" class="LineNr">304 </span><span class="traceContains">+mem: storing 2.5 in location 1</span>
<span id="L305" class="LineNr">305 </span>
<span id="L306" class="LineNr">306 </span><span class="Delimiter">:(scenario divide_by_zero)</span>
<span id="L307" class="LineNr">307 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L308" class="LineNr">308 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L309" class="LineNr">309 </span>]
<span id="L310" class="LineNr">310 </span><span class="traceContains">+mem: storing inf in location 1</span>
<span id="L311" class="LineNr">311 </span>
<span id="L312" class="LineNr">312 </span><span class="Delimiter">:(scenario divide_by_zero_2)</span>
<span id="L313" class="LineNr">313 </span><span class="Special">% Hide_errors = true;</span>
<span id="L314" class="LineNr">314 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L315" class="LineNr">315 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide-with-remainder <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L316" class="LineNr">316 </span>]
<span id="L317" class="LineNr">317 </span><span class="Comment"># integer division can't return floating-point infinity</span>
<span id="L318" class="LineNr">318 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: divide by zero in '1:num &lt;- divide-with-remainder 4, 0'</span>
<span id="L319" class="LineNr">319 </span>
<span id="L320" class="LineNr">320 </span><span class="Comment">//: Bitwise shifts</span>
<span id="L321" class="LineNr">321 </span>
<span id="L322" class="LineNr">322 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L323" class="LineNr">323 </span>SHIFT_LEFT<span class="Delimiter">,</span>
<span id="L324" class="LineNr">324 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L325" class="LineNr">325 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;shift-left&quot;</span><span class="Delimiter">,</span> SHIFT_LEFT<span class="Delimiter">);</span>
<span id="L326" class="LineNr">326 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L327" class="LineNr">327 </span><span class="Normal">case</span> SHIFT_LEFT: <span class="Delimiter">{</span>
<span id="L328" class="LineNr">328 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L329" class="LineNr">329 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-left' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L330" class="LineNr">330 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L331" class="LineNr">331 </span>  <span class="Delimiter">}</span>
<span id="L332" class="LineNr">332 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L333" class="LineNr">333 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-left' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L334" class="LineNr">334 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L335" class="LineNr">335 </span>  <span class="Delimiter">}</span>
<span id="L336" class="LineNr">336 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L337" class="LineNr">337 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-left' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L338" class="LineNr">338 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L339" class="LineNr">339 </span>  <span class="Delimiter">}</span>
<span id="L340" class="LineNr">340 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L341" class="LineNr">341 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-left' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L342" class="LineNr">342 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L343" class="LineNr">343 </span>  <span class="Delimiter">}</span>
<span id="L344" class="LineNr">344 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L345" class="LineNr">345 </span><span class="Delimiter">}</span>
<span id="L346" class="LineNr">346 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L347" class="LineNr">347 </span><span class="Normal">case</span> SHIFT_LEFT: <span class="Delimiter">{</span>
<span id="L348" class="LineNr">348 </span>  <span class="Comment">// ingredients must be integers</span>
<span id="L349" class="LineNr">349 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L350" class="LineNr">350 </span>  <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L351" class="LineNr">351 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L352" class="LineNr">352 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>b &lt; <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L353" class="LineNr">353 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span><a href='026call.cc.html#L87'>current_recipe_name</a><span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;second ingredient can't be negative in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span><a href='026call.cc.html#L89'>current_instruction</a><span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L354" class="LineNr">354 </span>    products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L355" class="LineNr">355 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L356" class="LineNr">356 </span>  <span class="Delimiter">}</span>
<span id="L357" class="LineNr">357 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>a&lt;&lt;b<span class="Delimiter">);</span>
<span id="L358" class="LineNr">358 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L359" class="LineNr">359 </span><span class="Delimiter">}</span>
<span id="L360" class="LineNr">360 </span>
<span id="L361" class="LineNr">361 </span><span class="Delimiter">:(scenario shift_left_by_zero)</span>
<span id="L362" class="LineNr">362 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L363" class="LineNr">363 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L364" class="LineNr">364 </span>]
<span id="L365" class="LineNr">365 </span><span class="traceContains">+mem: storing 1 in location 1</span>
<span id="L366" class="LineNr">366 </span>
<span id="L367" class="LineNr">367 </span><span class="Delimiter">:(scenario shift_left_1)</span>
<span id="L368" class="LineNr">368 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L369" class="LineNr">369 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">4</span>
<span id="L370" class="LineNr">370 </span>]
<span id="L371" class="LineNr">371 </span><span class="traceContains">+mem: storing 16 in location 1</span>
<span id="L372" class="LineNr">372 </span>
<span id="L373" class="LineNr">373 </span><span class="Delimiter">:(scenario shift_left_2)</span>
<span id="L374" class="LineNr">374 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L375" class="LineNr">375 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L376" class="LineNr">376 </span>]
<span id="L377" class="LineNr">377 </span><span class="traceContains">+mem: storing 12 in location 1</span>
<span id="L378" class="LineNr">378 </span>
<span id="L379" class="LineNr">379 </span><span class="Delimiter">:(scenario shift_left_by_negative)</span>
<span id="L380" class="LineNr">380 </span><span class="Special">% Hide_errors = true;</span>
<span id="L381" class="LineNr">381 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L382" class="LineNr">382 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">3</span><span class="Delimiter">,</span> -<span class="Constant">1</span>
<span id="L383" class="LineNr">383 </span>]
<span id="L384" class="LineNr">384 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: second ingredient can't be negative in '1:num &lt;- shift-left 3, -1'</span>
<span id="L385" class="LineNr">385 </span>
<span id="L386" class="LineNr">386 </span><span class="Delimiter">:(scenario shift_left_ignores_fractional_part)</span>
<span id="L387" class="LineNr">387 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L388" class="LineNr">388 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L389" class="LineNr">389 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>shift-left <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L390" class="LineNr">390 </span>]
<span id="L391" class="LineNr">391 </span><span class="traceContains">+mem: storing 2 in location 2</span>
<span id="L392" class="LineNr">392 </span>
<span id="L393" class="LineNr">393 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L394" class="LineNr">394 </span>SHIFT_RIGHT<span class="Delimiter">,</span>
<span id="L395" class="LineNr">395 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L396" class="LineNr">396 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;shift-right&quot;</span><span class="Delimiter">,</span> SHIFT_RIGHT<span class="Delimiter">);</span>
<span id="L397" class="LineNr">397 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L398" class="LineNr">398 </span><span class="Normal">case</span> SHIFT_RIGHT: <span class="Delimiter">{</span>
<span id="L399" class="LineNr">399 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L400" class="LineNr">400 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-right' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L401" class="LineNr">401 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L402" class="LineNr">402 </span>  <span class="Delimiter">}</span>
<span id="L403" class="LineNr">403 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L404" class="LineNr">404 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-right' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L405" class="LineNr">405 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L406" class="LineNr">406 </span>  <span class="Delimiter">}</span>
<span id="L407" class="LineNr">407 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L408" class="LineNr">408 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-right' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L409" class="LineNr">409 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L410" class="LineNr">410 </span>  <span class="Delimiter">}</span>
<span id="L411" class="LineNr">411 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L412" class="LineNr">412 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'shift-right' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L413" class="LineNr">413 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L414" class="LineNr">414 </span>  <span class="Delimiter">}</span>
<span id="L415" class="LineNr">415 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L416" class="LineNr">416 </span><span class="Delimiter">}</span>
<span id="L417" class="LineNr">417 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L418" class="LineNr">418 </span><span class="Normal">case</span> SHIFT_RIGHT: <span class="Delimiter">{</span>
<span id="L419" class="LineNr">419 </span>  <span class="Comment">// ingredients must be integers</span>
<span id="L420" class="LineNr">420 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L421" class="LineNr">421 </span>  <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L422" class="LineNr">422 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L423" class="LineNr">423 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>b &lt; <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L424" class="LineNr">424 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span><a href='026call.cc.html#L87'>current_recipe_name</a><span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;second ingredient can't be negative in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span><a href='026call.cc.html#L89'>current_instruction</a><span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L425" class="LineNr">425 </span>    products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L426" class="LineNr">426 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L427" class="LineNr">427 </span>  <span class="Delimiter">}</span>
<span id="L428" class="LineNr">428 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>a&gt;&gt;b<span class="Delimiter">);</span>
<span id="L429" class="LineNr">429 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L430" class="LineNr">430 </span><span class="Delimiter">}</span>
<span id="L431" class="LineNr">431 </span>
<span id="L432" class="LineNr">432 </span><span class="Delimiter">:(scenario shift_right_by_zero)</span>
<span id="L433" class="LineNr">433 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L434" class="LineNr">434 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L435" class="LineNr">435 </span>]
<span id="L436" class="LineNr">436 </span><span class="traceContains">+mem: storing 1 in location 1</span>
<span id="L437" class="LineNr">437 </span>
<span id="L438" class="LineNr">438 </span><span class="Delimiter">:(scenario shift_right_1)</span>
<span id="L439" class="LineNr">439 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L440" class="LineNr">440 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1024</span><span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L441" class="LineNr">441 </span>]
<span id="L442" class="LineNr">442 </span><span class="traceContains">+mem: storing 512 in location 1</span>
<span id="L443" class="LineNr">443 </span>
<span id="L444" class="LineNr">444 </span><span class="Delimiter">:(scenario shift_right_2)</span>
<span id="L445" class="LineNr">445 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L446" class="LineNr">446 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L447" class="LineNr">447 </span>]
<span id="L448" class="LineNr">448 </span><span class="traceContains">+mem: storing 1 in location 1</span>
<span id="L449" class="LineNr">449 </span>
<span id="L450" class="LineNr">450 </span><span class="Delimiter">:(scenario shift_right_by_negative)</span>
<span id="L451" class="LineNr">451 </span><span class="Special">% Hide_errors = true;</span>
<span id="L452" class="LineNr">452 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L453" class="LineNr">453 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">4</span><span class="Delimiter">,</span> -<span class="Constant">1</span>
<span id="L454" class="LineNr">454 </span>]
<span id="L455" class="LineNr">455 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: second ingredient can't be negative in '1:num &lt;- shift-right 4, -1'</span>
<span id="L456" class="LineNr">456 </span>
<span id="L457" class="LineNr">457 </span><span class="Delimiter">:(scenario shift_right_ignores_fractional_part)</span>
<span id="L458" class="LineNr">458 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L459" class="LineNr">459 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>divide <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L460" class="LineNr">460 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>shift-right <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L461" class="LineNr">461 </span>]
<span id="L462" class="LineNr">462 </span><span class="traceContains">+mem: storing 0 in location 2</span>
<span id="L463" class="LineNr">463 </span>
<span id="L464" class="LineNr">464 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L465" class="LineNr">465 </span>AND_BITS<span class="Delimiter">,</span>
<span id="L466" class="LineNr">466 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L467" class="LineNr">467 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;and-bits&quot;</span><span class="Delimiter">,</span> AND_BITS<span class="Delimiter">);</span>
<span id="L468" class="LineNr">468 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L469" class="LineNr">469 </span><span class="Normal">case</span> AND_BITS: <span class="Delimiter">{</span>
<span id="L470" class="LineNr">470 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L471" class="LineNr">471 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'and-bits' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L472" class="LineNr">472 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L473" class="LineNr">473 </span>  <span class="Delimiter">}</span>
<span id="L474" class="LineNr">474 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L475" class="LineNr">475 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'and-bits' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L476" class="LineNr">476 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L477" class="LineNr">477 </span>  <span class="Delimiter">}</span>
<span id="L478" class="LineNr">478 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L479" class="LineNr">479 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'and-bits' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L480" class="LineNr">480 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L481" class="LineNr">481 </span>  <span class="Delimiter">}</span>
<span id="L482" class="LineNr">482 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L483" class="LineNr">483 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'and-bits' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L484" class="LineNr">484 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L485" class="LineNr">485 </span>  <span class="Delimiter">}</span>
<span id="L486" class="LineNr">486 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L487" class="LineNr">487 </span><span class="Delimiter">}</span>
<span id="L488" class="LineNr">488 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L489" class="LineNr">489 </span><span class="Normal">case</span> AND_BITS: <span class="Delimiter">{</span>
<span id="L490" class="LineNr">490 </span>  <span class="Comment">// ingredients must be integers</span>
<span id="L491" class="LineNr">491 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L492" class="LineNr">492 </span>  <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L493" class="LineNr">493 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L494" class="LineNr">494 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>a&amp;b<span class="Delimiter">);</span>
<span id="L495" class="LineNr">495 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L496" class="LineNr">496 </span><span class="Delimiter">}</span>
<span id="L497" class="LineNr">497 </span>
<span id="L498" class="LineNr">498 </span><span class="Delimiter">:(scenario and_bits_1)</span>
<span id="L499" class="LineNr">499 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L500" class="LineNr">500 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">8</span><span class="Delimiter">,</span> <span class="Constant">3</span>
<span id="L501" class="LineNr">501 </span>]
<span id="L502" class="LineNr">502 </span><span class="traceContains">+mem: storing 0 in location 1</span>
<span id="L503" class="LineNr">503 </span>
<span id="L504" class="LineNr">504 </span><span class="Delimiter">:(scenario and_bits_2)</span>
<span id="L505" class="LineNr">505 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L506" class="LineNr">506 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">2</span>
<span id="L507" class="LineNr">507 </span>]
<span id="L508" class="LineNr">508 </span><span class="traceContains">+mem: storing 2 in location 1</span>
<span id="L509" class="LineNr">509 </span>
<span id="L510" class="LineNr">510 </span><span class="Delimiter">:(scenario and_bits_3)</span>
<span id="L511" class="LineNr">511 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L512" class="LineNr">512 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits <span class="Constant">14</span><span class="Delimiter">,</span> <span class="Constant">3</span>
<span id="L513" class="LineNr">513 </span>]
<span id="L514" class="LineNr">514 </span><span class="traceContains">+mem: storing 2 in location 1</span>
<span id="L515" class="LineNr">515 </span>
<span id="L516" class="LineNr">516 </span><span class="Delimiter">:(scenario and_bits_negative)</span>
<span id="L517" class="LineNr">517 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L518" class="LineNr">518 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">and</span>-bits -<span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
<span id="L519" class="LineNr">519 </span>]
<span id="L520" class="LineNr">520 </span><span class="traceContains">+mem: storing 4 in location 1</span>
<span id="L521" class="LineNr">521 </span>
<span id="L522" class="LineNr">522 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L523" class="LineNr">523 </span>OR_BITS<span class="Delimiter">,</span>
<span id="L524" class="LineNr">524 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L525" class="LineNr">525 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;or-bits&quot;</span><span class="Delimiter">,</span> OR_BITS<span class="Delimiter">);</span>
<span id="L526" class="LineNr">526 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L527" class="LineNr">527 </span><span class="Normal">case</span> OR_BITS: <span class="Delimiter">{</span>
<span id="L528" class="LineNr">528 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L529" class="LineNr">529 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'or-bits' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L530" class="LineNr">530 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L531" class="LineNr">531 </span>  <span class="Delimiter">}</span>
<span id="L532" class="LineNr">532 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L533" class="LineNr">533 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'or-bits' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L534" class="LineNr">534 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L535" class="LineNr">535 </span>  <span class="Delimiter">}</span>
<span id="L536" class="LineNr">536 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L537" class="LineNr">537 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'or-bits' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L538" class="LineNr">538 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L539" class="LineNr">539 </span>  <span class="Delimiter">}</span>
<span id="L540" class="LineNr">540 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L541" class="LineNr">541 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'or-bits' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L542" class="LineNr">542 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L543" class="LineNr">543 </span>  <span class="Delimiter">}</span>
<span id="L544" class="LineNr">544 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L545" class="LineNr">545 </span><span class="Delimiter">}</span>
<span id="L546" class="LineNr">546 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L547" class="LineNr">547 </span><span class="Normal">case</span> OR_BITS: <span class="Delimiter">{</span>
<span id="L548" class="LineNr">548 </span>  <span class="Comment">// ingredients must be integers</span>
<span id="L549" class="LineNr">549 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L550" class="LineNr">550 </span>  <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L551" class="LineNr">551 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L552" class="LineNr">552 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>a|b<span class="Delimiter">);</span>
<span id="L553" class="LineNr">553 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L554" class="LineNr">554 </span><span class="Delimiter">}</span>
<span id="L555" class="LineNr">555 </span>
<span id="L556" class="LineNr">556 </span><span class="Delimiter">:(scenario or_bits_1)</span>
<span id="L557" class="LineNr">557 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L558" class="LineNr">558 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">8</span>
<span id="L559" class="LineNr">559 </span>]
<span id="L560" class="LineNr">560 </span><span class="traceContains">+mem: storing 11 in location 1</span>
<span id="L561" class="LineNr">561 </span>
<span id="L562" class="LineNr">562 </span><span class="Delimiter">:(scenario or_bits_2)</span>
<span id="L563" class="LineNr">563 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L564" class="LineNr">564 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">10</span>
<span id="L565" class="LineNr">565 </span>]
<span id="L566" class="LineNr">566 </span><span class="traceContains">+mem: storing 11 in location 1</span>
<span id="L567" class="LineNr">567 </span>
<span id="L568" class="LineNr">568 </span><span class="Delimiter">:(scenario or_bits_3)</span>
<span id="L569" class="LineNr">569 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L570" class="LineNr">570 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">or</span>-bits <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">6</span>
<span id="L571" class="LineNr">571 </span>]
<span id="L572" class="LineNr">572 </span><span class="traceContains">+mem: storing 6 in location 1</span>
<span id="L573" class="LineNr">573 </span>
<span id="L574" class="LineNr">574 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L575" class="LineNr">575 </span>XOR_BITS<span class="Delimiter">,</span>
<span id="L576" class="LineNr">576 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L577" class="LineNr">577 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;xor-bits&quot;</span><span class="Delimiter">,</span> XOR_BITS<span class="Delimiter">);</span>
<span id="L578" class="LineNr">578 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L579" class="LineNr">579 </span><span class="Normal">case</span> XOR_BITS: <span class="Delimiter">{</span>
<span id="L580" class="LineNr">580 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">2</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L581" class="LineNr">581 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'xor-bits' requires exactly two ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L582" class="LineNr">582 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L583" class="LineNr">583 </span>  <span class="Delimiter">}</span>
<span id="L584" class="LineNr">584 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> || !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L585" class="LineNr">585 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'xor-bits' requires number ingredients, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L586" class="LineNr">586 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L587" class="LineNr">587 </span>  <span class="Delimiter">}</span>
<span id="L588" class="LineNr">588 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L589" class="LineNr">589 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'xor-bits' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L590" class="LineNr">590 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L591" class="LineNr">591 </span>  <span class="Delimiter">}</span>
<span id="L592" class="LineNr">592 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L593" class="LineNr">593 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'xor-bits' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L594" class="LineNr">594 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L595" class="LineNr">595 </span>  <span class="Delimiter">}</span>
<span id="L596" class="LineNr">596 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L597" class="LineNr">597 </span><span class="Delimiter">}</span>
<span id="L598" class="LineNr">598 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L599" class="LineNr">599 </span><span class="Normal">case</span> XOR_BITS: <span class="Delimiter">{</span>
<span id="L600" class="LineNr">600 </span>  <span class="Comment">// ingredients must be integers</span>
<span id="L601" class="LineNr">601 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L602" class="LineNr">602 </span>  <span class="Normal">int</span> b = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L603" class="LineNr">603 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L604" class="LineNr">604 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>a^b<span class="Delimiter">);</span>
<span id="L605" class="LineNr">605 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L606" class="LineNr">606 </span><span class="Delimiter">}</span>
<span id="L607" class="LineNr">607 </span>
<span id="L608" class="LineNr">608 </span><span class="Delimiter">:(scenario xor_bits_1)</span>
<span id="L609" class="LineNr">609 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L610" class="LineNr">610 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">8</span>
<span id="L611" class="LineNr">611 </span>]
<span id="L612" class="LineNr">612 </span><span class="traceContains">+mem: storing 11 in location 1</span>
<span id="L613" class="LineNr">613 </span>
<span id="L614" class="LineNr">614 </span><span class="Delimiter">:(scenario xor_bits_2)</span>
<span id="L615" class="LineNr">615 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L616" class="LineNr">616 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">10</span>
<span id="L617" class="LineNr">617 </span>]
<span id="L618" class="LineNr">618 </span><span class="traceContains">+mem: storing 9 in location 1</span>
<span id="L619" class="LineNr">619 </span>
<span id="L620" class="LineNr">620 </span><span class="Delimiter">:(scenario xor_bits_3)</span>
<span id="L621" class="LineNr">621 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L622" class="LineNr">622 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><span class="Normal">xor</span>-bits <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">6</span>
<span id="L623" class="LineNr">623 </span>]
<span id="L624" class="LineNr">624 </span><span class="traceContains">+mem: storing 2 in location 1</span>
<span id="L625" class="LineNr">625 </span>
<span id="L626" class="LineNr">626 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L627" class="LineNr">627 </span>FLIP_BITS<span class="Delimiter">,</span>
<span id="L628" class="LineNr">628 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L629" class="LineNr">629 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;flip-bits&quot;</span><span class="Delimiter">,</span> FLIP_BITS<span class="Delimiter">);</span>
<span id="L630" class="LineNr">630 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L631" class="LineNr">631 </span><span class="Normal">case</span> FLIP_BITS: <span class="Delimiter">{</span>
<span id="L632" class="LineNr">632 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L633" class="LineNr">633 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'flip-bits' requires exactly one ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L634" class="LineNr">634 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L635" class="LineNr">635 </span>  <span class="Delimiter">}</span>
<span id="L636" class="LineNr">636 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L637" class="LineNr">637 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'flip-bits' requires a number ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L638" class="LineNr">638 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L639" class="LineNr">639 </span>  <span class="Delimiter">}</span>
<span id="L640" class="LineNr">640 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L641" class="LineNr">641 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'flip-bits' yields one product in '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L642" class="LineNr">642 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L643" class="LineNr">643 </span>  <span class="Delimiter">}</span>
<span id="L644" class="LineNr">644 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; !is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">))</span> &amp;&amp; !is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L645" class="LineNr">645 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'flip-bits' should yield a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L646" class="LineNr">646 </span>    <span class="Identifier">goto</span> finish_checking_instruction<span class="Delimiter">;</span>
<span id="L647" class="LineNr">647 </span>  <span class="Delimiter">}</span>
<span id="L648" class="LineNr">648 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L649" class="LineNr">649 </span><span class="Delimiter">}</span>
<span id="L650" class="LineNr">650 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L651" class="LineNr">651 </span><span class="Normal">case</span> FLIP_BITS: <span class="Delimiter">{</span>
<span id="L652" class="LineNr">652 </span>  <span class="Comment">// ingredient must be integer</span>
<span id="L653" class="LineNr">653 </span>  <span class="Normal">int</span> a = <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L654" class="LineNr">654 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L655" class="LineNr">655 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>~a<span class="Delimiter">);</span>
<span id="L656" class="LineNr">656 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L657" class="LineNr">657 </span><span class="Delimiter">}</span>
<span id="L658" class="LineNr">658 </span>
<span id="L659" class="LineNr">659 </span><span class="Delimiter">:(scenario flip_bits_zero)</span>
<span id="L660" class="LineNr">660 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L661" class="LineNr">661 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">0</span>
<span id="L662" class="LineNr">662 </span>]
<span id="L663" class="LineNr">663 </span><span class="traceContains">+mem: storing -1 in location 1</span>
<span id="L664" class="LineNr">664 </span>
<span id="L665" class="LineNr">665 </span><span class="Delimiter">:(scenario flip_bits_negative)</span>
<span id="L666" class="LineNr">666 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L667" class="LineNr">667 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits -<span class="Constant">1</span>
<span id="L668" class="LineNr">668 </span>]
<span id="L669" class="LineNr">669 </span><span class="traceContains">+mem: storing 0 in location 1</span>
<span id="L670" class="LineNr">670 </span>
<span id="L671" class="LineNr">671 </span><span class="Delimiter">:(scenario flip_bits_1)</span>
<span id="L672" class="LineNr">672 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L673" class="LineNr">673 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">3</span>
<span id="L674" class="LineNr">674 </span>]
<span id="L675" class="LineNr">675 </span><span class="traceContains">+mem: storing -4 in location 1</span>
<span id="L676" class="LineNr">676 </span>
<span id="L677" class="LineNr">677 </span><span class="Delimiter">:(scenario flip_bits_2)</span>
<span id="L678" class="LineNr">678 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L679" class="LineNr">679 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>flip-bits <span class="Constant">12</span>
<span id="L680" class="LineNr">680 </span>]
<span id="L681" class="LineNr">681 </span><span class="traceContains">+mem: storing -13 in location 1</span>
<span id="L682" class="LineNr">682 </span>
<span id="L683" class="LineNr">683 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L684" class="LineNr">684 </span>ROUND<span class="Delimiter">,</span>
<span id="L685" class="LineNr">685 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L686" class="LineNr">686 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;round&quot;</span><span class="Delimiter">,</span> ROUND<span class="Delimiter">);</span>
<span id="L687" class="LineNr">687 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L688" class="LineNr">688 </span><span class="Normal">case</span> ROUND: <span class="Delimiter">{</span>
<span id="L689" class="LineNr">689 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L690" class="LineNr">690 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'round' requires exactly one ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L691" class="LineNr">691 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L692" class="LineNr">692 </span>  <span class="Delimiter">}</span>
<span id="L693" class="LineNr">693 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L694" class="LineNr">694 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;first ingredient of 'round' should be a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L695" class="LineNr">695 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L696" class="LineNr">696 </span>  <span class="Delimiter">}</span>
<span id="L697" class="LineNr">697 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L698" class="LineNr">698 </span><span class="Delimiter">}</span>
<span id="L699" class="LineNr">699 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L700" class="LineNr">700 </span><span class="Normal">case</span> ROUND: <span class="Delimiter">{</span>
<span id="L701" class="LineNr">701 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L702" class="LineNr">702 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>rint<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)));</span>
<span id="L703" class="LineNr">703 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L704" class="LineNr">704 </span><span class="Delimiter">}</span>
<span id="L705" class="LineNr">705 </span>
<span id="L706" class="LineNr">706 </span><span class="Delimiter">:(scenario round_to_nearest_integer)</span>
<span id="L707" class="LineNr">707 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L708" class="LineNr">708 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>round <span class="Constant">12.2</span>
<span id="L709" class="LineNr">709 </span>]
<span id="L710" class="LineNr">710 </span><span class="traceContains">+mem: storing 12 in location 1</span>
<span id="L711" class="LineNr">711 </span>
<span id="L712" class="LineNr">712 </span><span class="Delimiter">:(scenario round_halves_toward_zero)</span>
<span id="L713" class="LineNr">713 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L714" class="LineNr">714 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>round <span class="Constant">12.5</span>
<span id="L715" class="LineNr">715 </span>]
<span id="L716" class="LineNr">716 </span><span class="traceContains">+mem: storing 12 in location 1</span>
<span id="L717" class="LineNr">717 </span>
<span id="L718" class="LineNr">718 </span><span class="Delimiter">:(scenario round_halves_toward_zero_2)</span>
<span id="L719" class="LineNr">719 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L720" class="LineNr">720 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>round -<span class="Constant">12.5</span>
<span id="L721" class="LineNr">721 </span>]
<span id="L722" class="LineNr">722 </span><span class="traceContains">+mem: storing -12 in location 1</span>
<span id="L723" class="LineNr">723 </span>
<span id="L724" class="LineNr">724 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L725" class="LineNr">725 </span>TRUNCATE<span class="Delimiter">,</span>
<span id="L726" class="LineNr">726 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L727" class="LineNr">727 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;truncate&quot;</span><span class="Delimiter">,</span> TRUNCATE<span class="Delimiter">);</span>
<span id="L728" class="LineNr">728 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L729" class="LineNr">729 </span><span class="Normal">case</span> TRUNCATE: <span class="Delimiter">{</span>
<span id="L730" class="LineNr">730 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L731" class="LineNr">731 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'truncate' requires exactly one ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L732" class="LineNr">732 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L733" class="LineNr">733 </span>  <span class="Delimiter">}</span>
<span id="L734" class="LineNr">734 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L735" class="LineNr">735 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;first ingredient of 'truncate' should be a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L736" class="LineNr">736 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L737" class="LineNr">737 </span>  <span class="Delimiter">}</span>
<span id="L738" class="LineNr">738 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L739" class="LineNr">739 </span><span class="Delimiter">}</span>
<span id="L740" class="LineNr">740 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L741" class="LineNr">741 </span><span class="Normal">case</span> TRUNCATE: <span class="Delimiter">{</span>
<span id="L742" class="LineNr">742 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L743" class="LineNr">743 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>trunc<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)));</span>
<span id="L744" class="LineNr">744 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L745" class="LineNr">745 </span><span class="Delimiter">}</span>
<span id="L746" class="LineNr">746 </span>
<span id="L747" class="LineNr">747 </span><span class="Delimiter">:(scenario truncate_to_nearest_integer)</span>
<span id="L748" class="LineNr">748 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L749" class="LineNr">749 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><a href='101run_sandboxed.cc.html#L543'>truncate</a> <span class="Constant">12.2</span>
<span id="L750" class="LineNr">750 </span>]
<span id="L751" class="LineNr">751 </span><span class="traceContains">+mem: storing 12 in location 1</span>
<span id="L752" class="LineNr">752 </span>
<span id="L753" class="LineNr">753 </span><span class="Delimiter">:(scenario truncate_negative)</span>
<span id="L754" class="LineNr">754 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L755" class="LineNr">755 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span><a href='101run_sandboxed.cc.html#L543'>truncate</a> -<span class="Constant">12.2</span>
<span id="L756" class="LineNr">756 </span>]
<span id="L757" class="LineNr">757 </span><span class="traceContains">+mem: storing -12 in location 1</span>
<span id="L758" class="LineNr">758 </span>
<span id="L759" class="LineNr">759 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L760" class="LineNr">760 </span>SQUARE_ROOT<span class="Delimiter">,</span>
<span id="L761" class="LineNr">761 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L762" class="LineNr">762 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;square-root&quot;</span><span class="Delimiter">,</span> SQUARE_ROOT<span class="Delimiter">);</span>
<span id="L763" class="LineNr">763 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L764" class="LineNr">764 </span><span class="Normal">case</span> SQUARE_ROOT: <span class="Delimiter">{</span>
<span id="L765" class="LineNr">765 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L766" class="LineNr">766 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'square-root' requires exactly one ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L767" class="LineNr">767 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L768" class="LineNr">768 </span>  <span class="Delimiter">}</span>
<span id="L769" class="LineNr">769 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L770" class="LineNr">770 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;first ingredient of 'square-root' should be a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L771" class="LineNr">771 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L772" class="LineNr">772 </span>  <span class="Delimiter">}</span>
<span id="L773" class="LineNr">773 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L774" class="LineNr">774 </span><span class="Delimiter">}</span>
<span id="L775" class="LineNr">775 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L776" class="LineNr">776 </span><span class="Normal">case</span> SQUARE_ROOT: <span class="Delimiter">{</span>
<span id="L777" class="LineNr">777 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L778" class="LineNr">778 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>sqrt<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)));</span>
<span id="L779" class="LineNr">779 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L780" class="LineNr">780 </span><span class="Delimiter">}</span>
<span id="L781" class="LineNr">781 </span>
<span id="L782" class="LineNr">782 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<span id="L783" class="LineNr">783 </span>CHARACTER_TO_CODE<span class="Delimiter">,</span>
<span id="L784" class="LineNr">784 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<span id="L785" class="LineNr">785 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;character-to-code&quot;</span><span class="Delimiter">,</span> CHARACTER_TO_CODE<span class="Delimiter">);</span>
<span id="L786" class="LineNr">786 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<span id="L787" class="LineNr">787 </span><span class="Normal">case</span> CHARACTER_TO_CODE: <span class="Delimiter">{</span>
<span id="L788" class="LineNr">788 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L789" class="LineNr">789 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'character-to-code' requires exactly one ingredient, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L790" class="LineNr">790 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L791" class="LineNr">791 </span>  <span class="Delimiter">}</span>
<span id="L792" class="LineNr">792 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_character<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L793" class="LineNr">793 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;first ingredient of 'character-to-code' should be a character, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L794" class="LineNr">794 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L795" class="LineNr">795 </span>  <span class="Delimiter">}</span>
<span id="L796" class="LineNr">796 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L797" class="LineNr">797 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'character-to-code' requires exactly one product, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L798" class="LineNr">798 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L799" class="LineNr">799 </span>  <span class="Delimiter">}</span>
<span id="L800" class="LineNr">800 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_mu_number<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L801" class="LineNr">801 </span>    <a href='003trace.cc.html#L197'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;first product of 'character-to-code' should be a number, but got '&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L226'>end</a><span class="Delimiter">();</span>
<span id="L802" class="LineNr">802 </span>    <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L803" class="LineNr">803 </span>  <span class="Delimiter">}</span>
<span id="L804" class="LineNr">804 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L805" class="LineNr">805 </span><span class="Delimiter">}</span>
<span id="L806" class="LineNr">806 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
<span id="L807" class="LineNr">807 </span><span class="Normal">case</span> CHARACTER_TO_CODE: <span class="Delimiter">{</span>
<span id="L808" class="LineNr">808 </span>  <span class="Normal">double</span> result = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L809" class="LineNr">809 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L810" class="LineNr">810 </span>    result += ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L811" class="LineNr">811 </span>  <span class="Delimiter">}</span>
<span id="L812" class="LineNr">812 </span>  products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
<span id="L813" class="LineNr">813 </span>  products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L814" class="LineNr">814 </span>  <span class="Identifier">break</span><span class="Delimiter">;</span>
<span id="L815" class="LineNr">815 </span><span class="Delimiter">}</span>
<span id="L816" class="LineNr">816 </span>
<span id="L817" class="LineNr">817 </span><span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span id="L818" class="LineNr">818 </span><span class="Comment">#include &lt;math.h&gt;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->