title: I asked this yesterday, after the input given I'm still having trouble implementing
body: <p><strong>I'm not sure how to fix this or what I did wrong, but whenever I enter in a value it just closes out the run prompt.</strong></p>
  
  <p><strong>So, seems I do have a problem somewhere in my coding. Whenever I run the program and input a variable, it always returns the same answer.."The content at location 76 is 0."</strong> 
  On that note, someone told me that "I don't know, but I suspect that Program A incorrectly has a fixed address being branched to on instructions 10 and 11." - mctylr but I'm not sure how to fix that..</p>
  
  <p>I'm trying to figure out how to incorporate this idea from R Samuel Klatchko.. I'm still not sure what I'm missing but I can't get it to work..</p>
  
  <pre><code>const int OP_LOAD = 3;
  const int OP_STORE = 4;
  const int OP_ADD = 5;
  ...
  
  const int OP_LOCATION_MULTIPLIER = 100;
  
  mem[0] = OP_LOAD * OP_LOCATION_MULTIPLIER + ...;
  mem[1] = OP_ADD * OP_LOCATION_MULTIPLIER + ...;
  
  operand = memory[ j ] % OP_LOCATION_MULTIPLIER;
  operation = memory[ j ] / OP_LOCATION_MULTIPLIER;
  </code></pre>
  
  <p>I'm new to programming, I'm not the best, so I'm going for simplicity. Also this is an SML program. Anyway, this IS a homework assignment and I'm wanting a good grade on this. So I was looking for input and making sure this program will do what I'm hoping they are looking for. Anyway, here are the instructions: Write SML (Simpletron Machine language) programs to accomplish each of the following task:</p>
  
  <p>A) Use a sentinel-controlled loop to read positive number s and compute and print their sum. Terminate input when a neg number is entered.
  B) Use a counter-controlled loop to read seven numbers, some positive and some negative, and compute + print the avg.
  C) Read a series of numbers, and determine and print the largest number. The first number read indicates how many numbers should be processed.</p>
  
  <p>Without further a due, here is my program. All together.</p>
  
  <pre><code>int main()
  {
      const int READ = 10;
      const int WRITE = 11;
      const int LOAD = 20;
      const int STORE = 21;
      const int ADD = 30;
      const int SUBTRACT = 31;
      const int DIVIDE = 32;
      const int MULTIPLY = 33;
      const int BRANCH = 40;
      const int BRANCHNEG = 41;
      const int BRANCHZERO = 41;
      const int HALT = 43;
  
      int mem[100] = {0}; //Making it 100, since simpletron contains a 100 word mem.
  
      int operation; //taking the rest of these variables straight out of the book seeing as how they were italisized.
  
      int operand;
  
      int accum = 0; // the special register is starting at 0
  
      int j;
  
  
  
  
      // This is for part a, it will take in positive variables in a sent-controlled loop and compute + print their sum. Variables from example in text.
      memory [0] = 1010;
  
      memory [01] = 2009;
  
      memory [02] = 3008;
  
      memory [03] = 2109;
  
      memory [04] = 1109;
  
      memory [05] = 4300;
  
      memory [06] = 1009;
  
      j = 0; //Makes the variable j start at 0.
  
      while ( true )
      {
  
          operand = memory[ j ]%100; // Finds the op codes from the limit on the memory (100)
          operation = memory[ j ]/100;
  
          //using a switch loop to set up the loops for the cases
          switch ( operation ){
              case 10: //reads a variable into a word from loc. Enter in -1 to exit
                  cout &lt;&lt;"\n Input a positive variable:  ";
                  cin &gt;&gt; memory[ operand ]; break;
  
              case 11: // takes a word from location
                  cout &lt;&lt; "\n\nThe content at location " &lt;&lt; operand   &lt;&lt; "is " &lt;&lt; memory[operand]; break;
  
              case 20:// loads
                  accum = memory[ operand ]; break;
  
              case 21: //stores
                  memory[ operand ] = accum; break;
  
              case 30: //adds
                  accum += mem[operand]; break;
  
  
              case 31: // subtracts
                  accum-= memory[ operand ]; break;
  
              case 32: //divides
                  accum /=(memory[ operand ]); break;
  
              case 33: // multiplies
                  accum*= memory [ operand ]; break;
  
              case 40: // Branches to location
                  j = -1; break;
  
              case 41: //branches if acc. is &lt; 0
                  if (accum &lt; 0)
                  j = 5; 
                  break;
  
              case 42: //branches if acc = 0
                  if (accum == 0)
                      j = 5; 
                  break;
  
              case 43: // Program ends
                  exit(0); break;
      }
      j++;
      }
  return 0;
  }
  </code></pre>