about summary refs log tree commit diff stats
path: root/html/070text.mu.html
diff options
context:
space:
mode:
authorKartik K. Agaram <vc@akkartik.com>2016-05-26 19:01:35 -0700
committerKartik K. Agaram <vc@akkartik.com>2016-05-26 19:01:35 -0700
commita0decd22b6534663818c1780b1726d59cbe615c2 (patch)
tree9d3ac805613b3bdef0799fe4e3a29018c54e62fa /html/070text.mu.html
parentd3f1d63c7950b72dabf16b41fc9e9589e0e192cd (diff)
downloadmu-a0decd22b6534663818c1780b1726d59cbe615c2.tar.gz
3017
Diffstat (limited to 'html/070text.mu.html')
-rw-r--r--html/070text.mu.html254
1 files changed, 127 insertions, 127 deletions
diff --git a/html/070text.mu.html b/html/070text.mu.html
index 12114ddd..7b1c40d7 100644
--- a/html/070text.mu.html
+++ b/html/070text.mu.html
@@ -84,10 +84,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
-    <span class="Constant">3</span>:boolean/<span class="Special">raw &lt;- </span>equal x, x
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, x
   ]
   memory-should-contain [
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># x == x for all x</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># x == x for all x</span>
   ]
 ]
 
@@ -96,10 +96,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
-    <span class="Constant">3</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
   ]
   memory-should-contain [
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># abc == abc</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># abc == abc</span>
   ]
 ]
 
@@ -108,10 +108,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
-    <span class="Constant">3</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
   ]
   memory-should-contain [
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># abc != abcd</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># abc != abcd</span>
   ]
   trace-should-contain [
     text-equal: comparing lengths
@@ -126,10 +126,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
-    <span class="Constant">3</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
   ]
   memory-should-contain [
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># &quot;&quot; != abcd</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># &quot;&quot; != abcd</span>
   ]
 ]
 
@@ -138,10 +138,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abd]</span>
-    <span class="Constant">3</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal x, y
   ]
   memory-should-contain [
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># abc != abd</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># abc != abd</span>
   ]
 ]
 
@@ -246,33 +246,33 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     c:character<span class="Special"> &lt;- </span>copy <span class="Constant">99/c</span>
     x<span class="Special"> &lt;- </span>append x, c
     s2:address:array:character<span class="Special"> &lt;- </span>get *x, <span class="Constant">data:offset</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>equal s1, s2
-    <span class="Constant">2</span>:array:character/<span class="Special">raw &lt;- </span>copy *s2
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal s1, s2
+    <span class="Constant">11</span>:array:character/<span class="Special">raw &lt;- </span>copy *s2
 <span class="Constant">    +buffer-filled</span>
     c:character<span class="Special"> &lt;- </span>copy <span class="Constant">100/d</span>
     x<span class="Special"> &lt;- </span>append x, c
     s3:address:array:character<span class="Special"> &lt;- </span>get *x, <span class="Constant">data:offset</span>
-    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>equal s1, s3
-    <span class="Constant">11</span>:number/<span class="Special">raw &lt;- </span>get *x, <span class="Constant">length:offset</span>
-    <span class="Constant">12</span>:array:character/<span class="Special">raw &lt;- </span>copy *s3
+    <span class="Constant">20</span>:boolean/<span class="Special">raw &lt;- </span>equal s1, s3
+    <span class="Constant">21</span>:number/<span class="Special">raw &lt;- </span>get *x, <span class="Constant">length:offset</span>
+    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *s3
   ]
   memory-should-contain [
     <span class="Comment"># before +buffer-filled</span>
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>   <span class="Comment"># no change in data pointer</span>
-    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">3</span>   <span class="Comment"># size of data</span>
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># data</span>
-    <span class="Constant">4</span><span class="Special"> &lt;- </span><span class="Constant">98</span>
-    <span class="Constant">5</span><span class="Special"> &lt;- </span><span class="Constant">99</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>   <span class="Comment"># no change in data pointer</span>
+    <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">3</span>   <span class="Comment"># size of data</span>
+    <span class="Constant">12</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># data</span>
+    <span class="Constant">13</span><span class="Special"> &lt;- </span><span class="Constant">98</span>
+    <span class="Constant">14</span><span class="Special"> &lt;- </span><span class="Constant">99</span>
     <span class="Comment"># in the end</span>
-    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>   <span class="Comment"># data pointer has grown</span>
-    <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">4</span>   <span class="Comment"># final length</span>
-    <span class="Constant">12</span><span class="Special"> &lt;- </span><span class="Constant">6</span>   <span class="Comment"># but data's capacity has doubled</span>
-    <span class="Constant">13</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># data</span>
-    <span class="Constant">14</span><span class="Special"> &lt;- </span><span class="Constant">98</span>
-    <span class="Constant">15</span><span class="Special"> &lt;- </span><span class="Constant">99</span>
-    <span class="Constant">16</span><span class="Special"> &lt;- </span><span class="Constant">100</span>
-    <span class="Constant">17</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
-    <span class="Constant">18</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">20</span><span class="Special"> &lt;- </span><span class="Constant">0</span>   <span class="Comment"># data pointer has grown</span>
+    <span class="Constant">21</span><span class="Special"> &lt;- </span><span class="Constant">4</span>   <span class="Comment"># final length</span>
+    <span class="Constant">30</span><span class="Special"> &lt;- </span><span class="Constant">6</span>   <span class="Comment"># but data's capacity has doubled</span>
+    <span class="Constant">31</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># data</span>
+    <span class="Constant">32</span><span class="Special"> &lt;- </span><span class="Constant">98</span>
+    <span class="Constant">33</span><span class="Special"> &lt;- </span><span class="Constant">99</span>
+    <span class="Constant">34</span><span class="Special"> &lt;- </span><span class="Constant">100</span>
+    <span class="Constant">35</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">36</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
@@ -287,12 +287,12 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     c:character<span class="Special"> &lt;- </span>copy <span class="Constant">8/backspace</span>
     x<span class="Special"> &lt;- </span>append x, c
     s:address:array:character<span class="Special"> &lt;- </span>buffer-to-array x
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *s
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *s
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>   <span class="Comment"># length</span>
-    <span class="Constant">2</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># contents</span>
-    <span class="Constant">3</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>   <span class="Comment"># length</span>
+    <span class="Constant">11</span><span class="Special"> &lt;- </span><span class="Constant">97</span>  <span class="Comment"># contents</span>
+    <span class="Constant">12</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
@@ -365,10 +365,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[hello,]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[ world!]</span>
     z:address:array:character<span class="Special"> &lt;- </span>append x, y
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello, world!]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello, world!]</span>
   ]
 ]
 
@@ -378,10 +378,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     x:address:array:character<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[ world!]</span>
     z:address:array:character<span class="Special"> &lt;- </span>append x, y
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[ world!]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[ world!]</span>
   ]
 ]
 
@@ -391,10 +391,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[hello,]</span>
     y:address:array:character<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
     z:address:array:character<span class="Special"> &lt;- </span>append x, y
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello,]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello,]</span>
   ]
 ]
 
@@ -403,10 +403,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     x<span class="Special"> &lt;- </span>replace x, <span class="Constant">98/b</span>, <span class="Constant">122/z</span>
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[azc]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[azc]</span>
   ]
 ]
 
@@ -427,10 +427,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     x<span class="Special"> &lt;- </span>replace x, <span class="Constant">97/a</span>, <span class="Constant">122/z</span>
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[zbc]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[zbc]</span>
   ]
 ]
 
@@ -439,10 +439,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     x<span class="Special"> &lt;- </span>replace x, <span class="Constant">99/c</span>, <span class="Constant">122/z</span>
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abz]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abz]</span>
   ]
 ]
 
@@ -451,10 +451,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     x<span class="Special"> &lt;- </span>replace x, <span class="Constant">100/d</span>, <span class="Constant">122/z</span>
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc]</span>
   ]
 ]
 
@@ -463,10 +463,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[banana]</span>
     x<span class="Special"> &lt;- </span>replace x, <span class="Constant">97/a</span>, <span class="Constant">122/z</span>
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *x
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[bznznz]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[bznznz]</span>
   ]
 ]
 
@@ -547,13 +547,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
 <span class="muScenario">scenario</span> interpolate-works [
   run [
     <span class="Constant">local-scope</span>
-    x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc _]</span>
+    x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc_ghi]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[def]</span>
     z:address:array:character<span class="Special"> &lt;- </span>interpolate x, y
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc def]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abcdefghi]</span>
   ]
 ]
 
@@ -563,11 +563,11 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[_, hello!]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     z:address:array:character<span class="Special"> &lt;- </span>interpolate x, y
-    <span class="Constant">1</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">1</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc, hello!]</span>
-    <span class="Constant">13</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># out of bounds</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc, hello!]</span>
+    <span class="Constant">22</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># out of bounds</span>
   ]
 ]
 
@@ -576,10 +576,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[hello, _]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     z:address:array:character<span class="Special"> &lt;- </span>interpolate x, y
-    <span class="Constant">4</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
+    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *z
   ]
   memory-should-contain [
-    <span class="Constant">4</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello, abc]</span>
+    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[hello, abc]</span>
   ]
 ]
 
@@ -775,10 +775,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[a/b]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>
   ]
 ]
 
@@ -786,10 +786,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>
   ]
 ]
 
@@ -797,10 +797,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[/abc]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># prefix match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># prefix match</span>
   ]
 ]
 
@@ -808,10 +808,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc/]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># suffix match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># suffix match</span>
   ]
 ]
 
@@ -819,10 +819,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># no match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># no match</span>
   ]
 ]
 
@@ -830,10 +830,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">4/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">4/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># no change</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># no change</span>
   ]
 ]
 
@@ -841,10 +841,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[ab/c/]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">0/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">2</span>  <span class="Comment"># first '/' of multiple</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">2</span>  <span class="Comment"># first '/' of multiple</span>
   ]
 ]
 
@@ -852,10 +852,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[ab/c/]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">3/start-index</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, <span class="Constant">47/slash</span>, <span class="Constant">3/start-index</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># second '/' of multiple</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># second '/' of multiple</span>
   ]
 ]
 
@@ -910,10 +910,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[bd]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># not found</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># not found</span>
   ]
 ]
 
@@ -922,10 +922,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[cd]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">2</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">2</span>
   ]
 ]
 
@@ -934,10 +934,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abcd]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[cde]</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>find-next x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># not found</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># not found</span>
   ]
 ]
 
@@ -978,10 +978,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[ab]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match found</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match found</span>
   ]
 ]
 
@@ -989,10 +989,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, x, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, x, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match found</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match found</span>
   ]
 ]
 
@@ -1001,10 +1001,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[a]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">4</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">4</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># never matches</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># never matches</span>
   ]
 ]
 
@@ -1013,10 +1013,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># always matches empty pattern given a valid index</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># always matches empty pattern given a valid index</span>
   ]
 ]
 
@@ -1025,10 +1025,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">4</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">4</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
   ]
 ]
 
@@ -1037,10 +1037,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
   ]
 ]
 
@@ -1048,10 +1048,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
   run [
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, x, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, x, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># matches because pattern is also empty</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># matches because pattern is also empty</span>
   ]
 ]
 
@@ -1060,10 +1060,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[bc]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">1</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">1</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># match</span>
   ]
 ]
 
@@ -1072,10 +1072,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[bc]</span>
-    <span class="Constant">1</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
+    <span class="Constant">10</span>:boolean/<span class="Special">raw &lt;- </span>match-at x, y, <span class="Constant">0</span>
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># no match</span>
   ]
 ]
 
@@ -1126,16 +1126,16 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[a/b]</span>
     y:address:array:address:array:character<span class="Special"> &lt;- </span>split x, <span class="Constant">47/slash</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>length *y
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>length *y
     a:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">0</span>
     b:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">1</span>
-    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
-    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
+    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
+    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">2</span>  <span class="Comment"># length of result</span>
-    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
-    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">2</span>  <span class="Comment"># length of result</span>
+    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
+    <span class="Constant">30</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
   ]
 ]
 
@@ -1144,19 +1144,19 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[a/b/c]</span>
     y:address:array:address:array:character<span class="Special"> &lt;- </span>split x, <span class="Constant">47/slash</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>length *y
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>length *y
     a:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">0</span>
     b:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">1</span>
     c:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">2</span>
-    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
-    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
-    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *c
+    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
+    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
+    <span class="Constant">40</span>:array:character/<span class="Special">raw &lt;- </span>copy *c
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># length of result</span>
-    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
-    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
-    <span class="Constant">30</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[c]</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">3</span>  <span class="Comment"># length of result</span>
+    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
+    <span class="Constant">30</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
+    <span class="Constant">40</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[c]</span>
   ]
 ]
 
@@ -1165,13 +1165,13 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[abc]</span>
     y:address:array:address:array:character<span class="Special"> &lt;- </span>split x, <span class="Constant">47/slash</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>length *y
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>length *y
     a:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">0</span>
-    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
+    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># length of result</span>
-    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc]</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">1</span>  <span class="Comment"># length of result</span>
+    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[abc]</span>
   ]
 ]
 
@@ -1180,10 +1180,10 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[]</span>
     y:address:array:address:array:character<span class="Special"> &lt;- </span>split x, <span class="Constant">47/slash</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>length *y
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>length *y
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># empty result</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">0</span>  <span class="Comment"># empty result</span>
   ]
 ]
 
@@ -1192,22 +1192,22 @@ body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color
     <span class="Constant">local-scope</span>
     x:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[a/b//c]</span>
     y:address:array:address:array:character<span class="Special"> &lt;- </span>split x:address:array:character, <span class="Constant">47/slash</span>
-    <span class="Constant">1</span>:number/<span class="Special">raw &lt;- </span>length *y
+    <span class="Constant">10</span>:number/<span class="Special">raw &lt;- </span>length *y
     a:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">0</span>
     b:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">1</span>
     c:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">2</span>
     d:address:array:character<span class="Special"> &lt;- </span>index *y, <span class="Constant">3</span>
-    <span class="Constant">10</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
-    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
-    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *c
-    <span class="Constant">40</span>:array:character/<span class="Special">raw &lt;- </span>copy *d
+    <span class="Constant">20</span>:array:character/<span class="Special">raw &lt;- </span>copy *a
+    <span class="Constant">30</span>:array:character/<span class="Special">raw &lt;- </span>copy *b
+    <span class="Constant">40</span>:array:character/<span class="Special">raw &lt;- </span>copy *c
+    <span class="Constant">50</span>:array:character/<span class="Special">raw &lt;- </span>copy *d
   ]
   memory-should-contain [
-    <span class="Constant">1</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># length of result</span>
-    <span class="Constant">10</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
-    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
-    <span class="Constant">30</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[]</span>
-    <span class="Constant">40</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[c]</span>
+    <span class="Constant">10</span><span class="Special"> &lt;- </span><span class="Constant">4</span>  <span class="Comment"># length of result</span>
+    <span class="Constant">20</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[a]</span>
+    <span class="Constant">30</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[b]</span>
+    <span class="Constant">40</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[]</span>
+    <span class="Constant">50</span>:array:character<span class="Special"> &lt;- </span><span class="Constant">[c]</span>
   ]
 ]