Welcome to the Lounge

string MorrisBitVector32(int S, int N)
      {
          //Need the mask for accessing the individual bits
          int[] _masks = new int[32];
          {
              _masks[0] = BitVector32.CreateMask();
          }
          for (int i = 1; i < 32; i++)
          {
              _masks[i] = BitVector32.CreateMask(_masks[i - 1]);
          }

          //Hopefully setes the path to the project folder
          string projectPath = System.IO.Path.GetFullPath(@"..\..\..\");


          using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "input.txt", FileMode.Create)))
          {
              BitVector32 v = new BitVector32();
              // Standard 3 = 11, 2=10,1=01 and
              // 00 is not more numbers in this BitVector32
              v[_masks[0]] = S >= 2;
              v[_masks[1]] = S != 2;
              //Writes a 32bit integer to the file
              writer.Write(v.Data);
          }


          for (int i = 1; i < N; i++)
          {
              Debug.WriteLine(i + 1);

              using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
              {
                  // Initiates variables for each N run
                  bool currMSB, currLSB, firstRun;
                  firstRun = true;
                  currMSB = false;
                  currLSB = false;
                  int count = 0;
                  int k = 0;
                  BitVector32 outputBits = new BitVector32();

                  using (BinaryWriter writer = new BinaryWriter(File.Open(projectPath + "output.txt", FileMode.Create)))
                  {

                      while (reader.BaseStream.Position != reader.BaseStream.Length)
                      {
                          BitVector32 inputBits = new BitVector32(reader.ReadInt32());
                          if (firstRun)
                          {
                              count = 1;
                              currMSB = inputBits[_masks[0]];
                              currLSB = inputBits[_masks[1]];
                          }


                          bool nextMSB, nextLSB;
                          for (int j = (firstRun ? 2 : 0); j < 32; j += 2)
                          {
                              nextMSB = inputBits[_masks[j]];
                              nextLSB = inputBits[_masks[j + 1]];

                              // If both values are zero that means that there
                              // are no more values in the BitVector32
                              if (!(nextLSB || nextMSB))
                              {
                                  break;
                              }

                              // The values continue
                              if ((currMSB == nextMSB) && (currLSB == nextLSB))
                              {
                                  count++;
                              }

                              // New values found sore and perhaps write to file
                              else
                              {
                                  if (k == 32)
                                  {
                                      //BitVector32 is full, need to store and create a new one
                                      writer.Write(outputBits.Data);
                                      outputBits = new BitVector32();
                                      k = 0;

                                      outputBits[_masks[k]] = count >= 2;
                                      k++;
                                      outputBits[_masks[k]] = count != 2;
                                      k++;
                                      outputBits[_masks[k]] = currMSB;
                                      k++;
                                      outputBits[_masks[k]] = currLSB;
                                      k++;
                                      currMSB = nextMSB;
                                      currLSB = nextLSB;
                                      count = 1;
                                  }
                                  else
                                  {
                                      //More room left in the BitVector32
                                      outputBits[_masks[k]] = count >= 2;
                                      k++;
                                      outputBits[_masks[k]] = count != 2;
                                      k++;
                                      outputBits[_masks[k]] = currMSB;
                                      k++;
                                      outputBits[_masks[k]] = currLSB;
                                      k++;
                                      currMSB = nextMSB;
                                      currLSB = nextLSB;
                                      count = 1;
                                  }
                              }

                              // Used to initiate the current number
                              if (firstRun)
                                  firstRun = false;
                          }
                      }

                      //Write out the remaining data
                      if (k == 32)
                      {
                          writer.Write(outputBits.Data);
                          outputBits = new BitVector32();
                          k = 0;

                          outputBits[_masks[k]] = count >= 2;
                          k++;
                          outputBits[_masks[k]] = count != 2;
                          k++;
                          outputBits[_masks[k]] = currMSB;
                          k++;
                          outputBits[_masks[k]] = currLSB;
                          k++;
                          writer.Write(outputBits.Data);
                      }
                      else
                      {

                          outputBits[_masks[k]] = count >= 2;
                          k++;
                          outputBits[_masks[k]] = count != 2;
                          k++;
                          outputBits[_masks[k]] = currMSB;
                          k++;
                          outputBits[_masks[k]] = currLSB;
                          k++;
                          writer.Write(outputBits.Data);
                      }
                  }
              }

              // Exchange the input and output files
              File.Delete(projectPath + "input.txt");
              System.IO.File.Copy(projectPath + "output.txt", projectPath + "input.txt");
              System.IO.File.WriteAllText(projectPath + "output.txt", string.Empty);
          }


          StringBuilder output = new StringBuilder();
          using (BinaryReader reader = new BinaryReader(File.Open(projectPath + "input.txt", FileMode.Open)))
          {
              bool nextMSB, nextLSB;
              while (reader.BaseStream.Position != reader.BaseStream.Length)
              {
                  BitVector32 InputData = new BitVector32(reader.ReadInt32());
                  for (int i = 0; i < 32; i+=2)
                  {
                      nextMSB = InputData[_masks[i]];
                      nextLSB= InputData[_masks[i+1]];

                      if (!(nextLSB || nextMSB))
                          break;

                      if (nextMSB && nextLSB)
                          output.Append("3");
                      else
                      {
                          if (nextMSB)
                              output.Append("2");
                          else
                              output.Append("1");
                      }

                  }
              }
          }

          return output.ToString();
      }

level 1 size = 1
level 2 size = 2
level 3 size = 2
level 4 size = 4
level 5 size = 6
level 6 size = 6
level 7 size = 8
level 8 size = 10
level 9 size = 14
level 10 size = 20
level 11 size = 26
level 12 size = 34
level 13 size = 46
level 14 size = 62
level 15 size = 78
level 16 size = 102
level 17 size = 134
level 18 size = 176
level 19 size = 226
level 20 size = 302
level 21 size = 408
level 22 size = 528
level 23 size = 678
level 24 size = 904
level 25 size = 1182
level 26 size = 1540
level 27 size = 2012
level 28 size = 2606
level 29 size = 3410
level 30 size = 4462
level 31 size = 5808
level 32 size = 7586
level 33 size = 9898
level 34 size = 12884
level 35 size = 16774
level 36 size = 21890
level 37 size = 28528
level 38 size = 37158
level 39 size = 48410
level 40 size = 63138
level 41 size = 82350
level 42 size = 107312
level 43 size = 139984
level 44 size = 182376
level 45 size = 237746
level 46 size = 310036
level 47 size = 403966
level 48 size = 526646
level 49 size = 686646
level 50 size = 894810
level 51 size = 1166642
level 52 size = 1520986
level 53 size = 1982710
level 54 size = 2584304
level 55 size = 3369156
level 56 size = 4391702
level 57 size = 5724486
level 58 size = 7462860
level 59 size = 9727930
level 60 size = 12680852
level 61 size = 16530884
level 62 size = 21549544
level 63 size = 28091184
level 64 size = 36619162
level 65 size = 47736936
level 66 size = 62226614
level 67 size = 81117366
level 68 size = 105745224
level 69 size = 137842560
level 70 size = 179691598
level 71 size = 234241786
level 72 size = 305351794
level 73 size = 398049970
level 74 size = 518891358
level 75 size = 676414798
level 76 size = 881752750
level 77 size = 1149440192
level 78 size = 1498380104
level 79 size = 1953245418
level 80 size = 2546222700
level 81 size = 3319186080
level 82 size = 4326816254
level 83 size = 5640348764
level 84 size = 7352630884
level 85 size = 9584715106
level 86 size = 12494412020
level 87 size = 16287462624
level 88 size = 21231903676
level 89 size = 27677468012
level 90 size = 36079732206
level 91 size = 47032657188
level 92 size = 61310766500
level 93 size = 79923316046
level 94 size = 104186199146
level 95 size = 135814773100
level 96 size = 177045063068
level 97 size = 230791944956
level 98 size = 300854953626
level 99 size = 392187941864
level 100 size = 511247092564
finished computation at Fri Dec  1 16:48:41 2017
elapsed time: 7205.75secs

#include <stdio.h>
#include <stdlib.h>

class s {
private:
	char indx;
	char ondx;
	char v[10];
public:
	bool done;
	unsigned long long count;
	s(void) {
		indx = '\0';
		ondx = '\0';
		done = false;
		count= 0UL;
	}
	void put (char c) {
		v[indx++] = c;
		indx = indx % 10;
	}
	char get (void) {
		char c = v[ondx++];
		ondx = ondx %10;
		return c;
	}
	char peek (void) {
		return v[ondx];
	}
	bool isEmpty (void) {
		return indx == ondx;
	}
};

s context[100];

// the two functions "nextItem" and "doCount" call each other recursively.

bool nextItem (char& c, int level);

// count number of consecutive instances of v from level below
// return count as a character in 'c'; save v with msb set. and
// character which terminated count in context.
void doCount (char& c, char v, int level) {
	bool	r = false;
	s&	x = context[level];
	c = '1';
	x.put (v + 0X80);
	while (!x.done) {
		char t;
		x.done = nextItem (t, level - 1);
		if (t == v) {
			c++;
		}
		else {
			// count is complete so we need to put the terminating value
			// in the buffer, value we are counting is already there
			x.put (t);
			break;
		}
	}
}

// return in 'c' the next character from the specified level
// signal done if that character is the last.
// there are two special cases:
// 1) level = 0, the single character '1' is returned and done is signalled
// 2) There are no characters held in the context (this must be the first entry)
// Otherwise there are one or two characters in the context. If the next character 
// held in the context ha the msb set, the count has already been returned so the 
// character should be returned. Otherwise the character is the terminating character
// from the last count and more repetitions (if any) must be counted, after which the
// count is returned. When the lower level has signalled done, then when the last
// character is returned also signal done.
// Count the number of characters returned and when the last character is returned and 
// done s signalled, report the level and the total.

bool nextItem (char& c, int level) {
	s&	x = context[level];
	bool		r = false;
	if (!x.isEmpty()) {
		// more ready to output
		char v = x.get();
		c = v & 0X7F;
		if (v & 0X80) {
			r = x.isEmpty();
		}
		else {
			// this is the next value and we need to count any more
			doCount (c, v, level);
		}
	}
	else if (level == 0) {
		// at the lowest level the seed is a single '1'
		c = '1';
		x.done = true;
		r = true;
	}
	else if (x.isEmpty()) {
		// nothing prepared, must be first time get character from lower level
		char t;
		x.done = nextItem(t, level - 1);
		doCount (c, t, level);
	}
	x.count++;
	if (r) {
		fprintf (stdout, "%3d: %llu digits\n", level + 1, x.count);
	}
	return r;
}

int main(int argc, char *argv[]) {
	char t;
	
	while (!nextItem(t, 99)) {
		;
	}
}
</blockquote>