Merge pull request #2512 from xexyl/html-quotes

Fix code blocks in 1991 and part of 1992

1992/adrian/README.md

@@ -71,7 +71,9 @@ significant to only eight characters like `chars1`.
 ### Example 1: matches `^abc$`
 
 ```
-    <q0> a <q1>          The first state to appear is the start state
+    <q0> a <q1>   The first state to
+                  appear is the
+                  start state
     <q1> b <q2>
     <q2> c [q3]
     [q3]

1992/adrian/index.html

@@ -437,7 +437,9 @@ should have a similar specification somewhere. A state is accepting if
 it is specified in square brackets: <code>[final]</code>; state strings are
 significant to only eight characters like <code>chars1</code>.</p>
 <h3 id="example-1-matches-abc">Example 1: matches <code>^abc$</code></h3>
-<pre><code>    &lt;q0&gt; a &lt;q1&gt;          The first state to appear is the start state
+<pre><code>    &lt;q0&gt; a &lt;q1&gt;   The first state to
+                  appear is the
+                  start state
     &lt;q1&gt; b &lt;q2&gt;
     &lt;q2&gt; c [q3]
     [q3]</code></pre>

1992/buzzard.1/README.md

@@ -224,12 +224,12 @@ This is more obscured by factoring out common terms and restricting
 ourselves to two operand operations:
 
 ``` <!---c-->
-    temp = z;                       (temp == z)
-    temp -= y;                      (temp == z-y)
-    temp *= x;                      (temp == (z-y)*x)
-    y += temp;                      (y    == (z-y)*x + y)
-                                    (     == z*x - y*x + y)
-                                    (     == z*x + y*(1-x))
+    temp = z;       (temp == z)
+    temp -= y;      (temp == z-y)
+    temp *= x;      (temp == (z-y)*x)
+    y += temp;      (y    == (z-y)*x + y)
+                    (     == z*x - y*x + y)
+                    (     == z*x + y*(1-x))
 ```
 
 Next we imagine we have a [pc](https://en.wikipedia.org/wiki/Program_counter).

1992/buzzard.1/index.html

@@ -549,12 +549,12 @@ simply compute:</p>
 <pre><code>    y = (z * x) + (y * (1-x));</code></pre>
 <p>This is more obscured by factoring out common terms and restricting
 ourselves to two operand operations:</p>
-<pre><code>    temp = z;                       (temp == z)
-    temp -= y;                      (temp == z-y)
-    temp *= x;                      (temp == (z-y)*x)
-    y += temp;                      (y    == (z-y)*x + y)
-                                    (     == z*x - y*x + y)
-                                    (     == z*x + y*(1-x))</code></pre>
+<pre><code>    temp = z;       (temp == z)
+    temp -= y;      (temp == z-y)
+    temp *= x;      (temp == (z-y)*x)
+    y += temp;      (y    == (z-y)*x + y)
+                    (     == z*x - y*x + y)
+                    (     == z*x + y*(1-x))</code></pre>
 <p>Next we imagine we have a <a href="https://en.wikipedia.org/wiki/Program_counter">pc</a>.
 “I’m supposed to execute statement pc next”, says our emulator. But suppose
 we’re not currently coming up on statement pc. To handle this, we simply make