title: Why overflows are omitted in the non-restoring hardware binary division algorithm?
body: <p>I'm reading a book about a hardware friendly version of non-restoring binary division algorithm, for example <code>52_octal</code> divided by <code>41_octal</code>:</p>
  
  <pre><code>Round | Action            | Divisor | Remainder(6 bits) appended Quotient(6 bits)  
  ------+-------------------+---------+----------------------------------------------
  0     | Init Value        | 100 001 | 000 000 101 010
        | R&gt;0, RQ &lt;&lt; 0, Sub | 100 001 | 000 001 010 100
  ------+-------------------+---------+----------------------------------------------
  1     | R=R-D             | 100 001 | 100 000 010 100
        | R&lt;0, RQ &lt;&lt; 0, Add | 100 001 | 000 000 101 000 &lt;--- Now the remainder bits overflow!
  ------+-------------------+---------+----------------------------------------------
  2     | R=R+D             | 100 001 | 100 001 101 000
        | R&lt;0, RQ &lt;&lt; 0, Add | 100 001 | 000 011 010 000 &lt;--- Overflow again.
  ------+-------------------+---------+----------------------------------------------
  3     | R=R+D             | 100 001 | 100 100 010 000
        | R&lt;0, RQ &lt;&lt; 0, Add | 100 001 | 001 000 100 000 &lt;--- Overflow again.
  ------+-------------------+---------+----------------------------------------------
  4     | R=R+D             | 100 001 | 101 001 100 000
        | R&lt;0, RQ &lt;&lt; 0, Add | 100 001 | 010 011 000 000 &lt;--- Overflow again.
  ------+-------------------+---------+----------------------------------------------
  5     | R=R+D             | 100 001 | 110 100 000 000
        | R&lt;0, RQ &lt;&lt; 0, Add | 100 001 | 101 000 000 000 &lt;--- Overflow again.
  ------+-------------------+---------+----------------------------------------------
  6     | R=R+D             | 100 001 | 001 001 000 000
        | R&gt;0, RQ &lt;&lt; 1, Sub | 100 001 | 010 010 000 001
  ------+-------------------+---------+----------------------------------------------
        | Shift R-part right 1 bit    | 001 001 000 001
                                      | R=11_oct | Q=1_oct
  End
  </code></pre>
  
  <p>Why won't this cause an error? I follow this algorithm and it gives right answer...</p>