Friday, September 23, 2016

THIS BLOG IS GETTING HACKED

Copyright (C) 2016 http://time-travel.institute


Ray Hudson, Darby Phillips, And Pamela from the John Titor story. I suspect they are CIA intelligence agents.

 Since 2008 they have been running me off the forums around the internet so I started this blog to tell my side of the story in 2010. They have also suppressed my post at Wikipedia and other places.

 Well, in 2013 they hired a hacker to hack me at home that story is in my blog.

 Shortly after this hacking their hacker threaten me with violence on Craig's List in and around 2013. He told me I was going to have a accident.

 As of September 2016 they have started breaking into my blog and deleting parts of my blog further suppressing my freedom of speech more they they all ready have as well as hacking my home computer and network.

 I have been going back and fixing what I can. I think they starting deleting parts of my blog because I started posting computer code that would enable people to time travel with their computers.

 Strangely it was my algorithms, code, and program outlines they deleted and not the nasty things I said about them. So, it is my code, program outlines, and algorithms they do not want the public to see. And most importantly that is the easiest thing for me to replace as they delete it.

 And another thing. These guys may have won most of their online battles against me but they "LOST THE WAR"!!! They failed to prevent book 1 from being published and they failed at keeping books 2, 3, and 4 from getting published. They failed to stop me from publishing my DVD's. They failed to stop me from posting my algorithms, program outlines, and computer code online. They failed completely.

 So, they lost the war. They might as well go home with their dog tails between their legs. This attacking my blog is simply them throwing their little temper tantrums and crying like the bawling babies they really are. WAH, WAH, WAH, BAAAAAAHAHAHAHAHAHAHAHAH!!!! LOL.

 So, this is the reasons they are hacking my blog and deleting parts of my post.

 I will do my best to rebuild what they try to destroy. But they can't stop the truth.

 I have contacted the FBI and Homeland and my local authorities but since these guys are CIA there has been little I can do.

 I apologize to the public for any inconvenience Ray Hudson, Darby Phillips, Pamela, and Aaron Hiniker have caused the public in reading the true story of how to time travel with a computer.

 I will continue to keep this blog up as long as I can.

 This is a public notice.

 Thanks,
Lloyd Burris AKA Reactor1967

 ---------------------------------------------------------------------------------------------------

 In the computer program outline I previously posted I have been going back and filling in the outline with working computer code and testing it to make sure it works and making it better. My goal is to give the public something simple they can use to do the same work that I do with my more complex code.

 I am going to provide the public with a working binary counter and a means to control the speed of that counter so that everyone else can play with temporal mathematics like I do.

 I also will go back and rewrite my previous post and make put in simple useful subs so again the public can experiment with temporal mathematics like I do.

 All this will take a bit. So hold tight. I have been doing this since 2008 and I don't get in a hurry because I all I have is time.

 And last thing when I make this big update I will also be updating fire codes at source forge with a program that people can use to back up their computer files to a single text file with check sums. They can use this file and my program to reconstruct their computer files.

 It will be free. And taking it a step further of course they can use it to find time travel computer media.

 When I rewrite my previous post I will update it for the algorithm I am posting here now.

 Here is the algorithm for speeding up the counter and slowing it down to bring the counter file into sync with its target check sum.
The reason for this is as the counter runs the destination check sum will get bigger then its target check sum then get smaller than its target check sum then get bigger than its target check sum over and over again. I am talking about the strong check sum.

 So the method I devised was increase the speed of the counter. Ever time the destination check sum gets closer to the target check sum I back up the counter. That is the one I keep. If the target check sum passes up the destination check sum. I delete the counter and restore the back up. I do this over and over again until the destination check sum and the target check sum are equal. Then then file has been reconstructed.

 <<<<<<<<<<<<<<<
 create counter file
create speed.bin file
Load configure file.(This file holds the target strong check sum, target weak check sum, and target file size of the file we are reconstructing.)
start counter loop
get destination check sum
get diff1 = destination check sum minus target check sum
back up counter
roll counter (This is where we use base 256 and add speed.bin to counter.bin)
get diff2 (destination check sum - target check sum)
if diff2 < diff1 keep counter
if diff2 > diff1 delete counter restore back up
increase speed of counter till it is maxed out then decrease speed of counter till it bottoms out then reverse and start increasing counter speed again.(To increase counter speed make speed.bin larger. To decrease counter speed make speed.bin smaller.)
repeat counter loop
<<<<<<<<<<<<<<<<<< End example
Using this method to run a check sum counter you can check sum hack computer files. Now for me I mathematically calculate the strong check-sum(s) of the files I want and I use my check sum hacking to recreate those files. So, I get to read, watch, view, and listen to computer media files of the past, present, future, and alternate time lines.

 The method of increasing and decreasing the counter speed to roll the counter to a specific binary strong check sum is similar to how a carpenter works with wood. You see a carpenter can take a piece of wood and shape it by cutting it and working it into a specific shape. That is what I do with computer files. I get my counter.bin file and like a carpenter working with wood I work the file till I have molded it and shaped it into what I want.

 What I want though is a computer media file that can be from the future or the past. Information don't care when, where, or how it exist. Information just does not care.

 Well that is it for today. Give me time I will get this blog updated.


 I am going to leave you today with something funny my brother told me this afternoon. I was offering him my check sum hacking software. He said to me

 "Brother you don't have to worry about anyone stealing your shit. You see, the only person that knows how to use your shit is you. No one else can figure the crap out. Your software is safe."

 I just laughed and laughed. It brought back memories 3 years ago when Aaron Hiniker was trying to figure out how my BNS worked. He can emailing me and emailing me and asking me one question after another.

 When I bring my software to the public I will do my best to make it user friendly. One of the reasons I can't post what I use is for the very reason no one would know how to use it but me. For example. I change the buffer size (how many bytes the program can read at a time.) I change the base that I am working it. In what I show the public I work in base 256. But if I want the program to run faster I have to use higher bases and higher buffer sizes. I create more threads. I create more instances of the same program running. I do lots of things most of the general public could not keep up with.

 So, when I do post code or algorithms I try to keep it simple but us-able so the public  can use it.

 Time-Hacking and Check-Sum-Hacking is complicated but its not hard once you understand the concepts of how to do it. You have to learn to crawl before you can walk.

 First you learn to check sum hack and make it work.
Then you learn how to predict check sums of computer media files from the past, present, future, and other time lines.
Now, once you can do that you can use the check sum hacking to create time travel media files of the past, present, future, and other time lines. THEN YOU CAN FINALLY WALK. OR SHOULD I SAY, TIME TRAVEL!!!

 Ok, that's it for today.
===============================================

 Well I guess the "Conspiracy Against Time Travel" aka NSA, CIA, FBI, and god knows who else and their thugs Darby Phillips, Ray Hudson, Pamela aka Dog Bitch, and Aaron Hiniker my so called "Friend pal and buddy" finally caught up on their reading of my blog.

 Because today they attacked my home computer and home network so forcefully and fiercely that both my computer and network were completely un-usable.

 They got my computer with virus and malware and did a denial of service attack on my home network.

 So, I refreshed my IP and reset my connection to my ISP then I took my computer down and formatted my hard drive and re-imaged it.

 After that I sat down and had an adult beverage and laughed my ass off at the "Conspiracy Against Time Travel".

 I guess I got attacked so hard for posting my code which I was warned against my Ray Hudson and for saying that Ray, Pamela, and Aaron should give Darby a pity fuck.

BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

 Ok my ribs are hurting so I should stop.

If Ray, Aaron, and Pamela did give Darby a pity fuck that old troll would probably ride those three like Grand Canyon Pack Mulls!!!!
Slapping their asses and the whole 9 yards!!!!!!!!!!!!!

BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAHAAHAH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


Oh crap now my I should really stop. I got tears here I'm laughing so hard!!!!

 Right now I was running a binary counter reconstructing a text file. On my program outline I am giving the public I have a binary counter working, I have a speed control for that binary counter counter working, and a have a save and restore counter feature working.

 I am thinking about what else to put in it. The public will be able to use this to search for text files from the past, present, future, or alternate time lines. I have a temporal email system I use with my A/B algorithm.

 So, I am still pondering what else to put in it to give the public.
That is it for me today. Here is a screen shoot of my traffic.



---------------------------------------------------------------------------
In my previous post I have computer code, algorithms, program outlines, and videos. I have showed and proved I can check sum hack. Without getting out my own time travel program and using my own code and algorithms I have been constructing the public their own time travel software which they can take at beginner level and refine and improve on their own.

I have a 8 cpu 32 gig of computer memory desktop computer I call time travel one station. Over the years this baby has been my main computer for time hacking. 

In my previous post in my code and videos I have done very basic beginner level check sum hacking with the public.

What I want the public to know is they can use statistics to take a sample of known computer media and learn how to break that down into 3 or 4 bytes at a time and run in parallel my software. 

This can be used to take a long chain of check-sums and construct files piece by piece then put those pieces together as a time travel media file. Rsync did this in their software years ago. It constructed computer files by breaking them down into chains. Constructing those chains with check-sums. Then putting the files back together.

Then, this method can be used to time-hack computer files.

I might include a post later showing how to specifically do that as well as putting that method in the public version of my time travel software I am making for the public to use.

Now, in my own code I do the whole file at once by throttling my counter and I am working to put that into the public version of my software but still for the ones wanting to do time hacking now breaking the check-sums up into pieces and running them in parallel is a option. I will probably include this as a option in my public version of my time travel software in the future.

Boy, I have taken some heat this weak for publishing a public  version of my time travel software. My home network got taken completely offline by the what I think may be the CIA. Boy they are pissed.

What are they going to do to me when the whole program outline is finished and posted on the internet?

I've done nothing wrong.

I am not a scientist, nor a government employee or contractor, I have broken no laws. I am a simple man that likes to time travel with his computer by using check sum hacking to time hack computer media files from across space-time.

I want to tell everyone my code in my previous post is good for using my A/B algorithm for temporal communication. It is also good for finding any other type of files from the future or past even the present. I don't have the counter throttling in yet but it can be used as a parallel program for faster results.

Part of my studies included reading about how scientist could tell if dolphins and whales were communicating. I read how they graphed their communications onto charts to tell if it was information or noise. I took the same methods for helping me plot my check-sums containing information of computer files from the future or the past. Then constructing those check-sums. 

Which makes me the first real time traveler.

I at one time I took ancient hieroglyphics and using my computer time travel methods I was able to decode ancient text from ancient civilizations. 

All the lost scrolls and lost tablets of the past became available to me with my methods. Lost ancient writings and lost ancient knowledge became available to me with my time travel methods.

When Ray Hudson asked me about my level of access at http://abovetopsecret.com well my level of access is 1000% no that is not a typo. I have one thousand percent access to knowledge from all across space time with my methods of computer time travel.

Ray Hudson the secret to that 1000% access is by constructing a check-sum map. On this map the locations of known computer files are put. Then locations of unknown computer files can be explored. As those files are found they are also put on this check-sum map. As the files change their differences between each other are noted. A journal is kept that pieces together what files are in the same time line and what files belong in other time lines. It is like putting a at sea rescue mission married together with a law enforcement investigation married together with a scientific investigation. 

The is TIME TRAVEL CENTRAL MISSION CONTROL. Using this method I can plot where I am in my access to space time and where I need to go in my access to space time. This is how you establish access to space-time.

This is why my computer network was knocked off line this week by the CIA. So, I could not talk to the public about my work. I still have to use a outside internet connection to connect to my blog. 

As I complete more of the public version of my time travel code things might get a little hairy for me. I advise everyone interested in my work to copy everything I have posted while they still can and purchase what books of mine they can find while they still can. I have a youtube channel. I am reactor1697 is my handle. My web-sight which may be up or down depending on the mood of the "Conspiracy Against Time Travel" is http://time-travel.institute

What makes my software different from computers that can write or play chess is my software once locked in on the correct check sums can decode movies of actual murders being performed where the killer was never caught and brought to justice.

It can be used to time hack computers without ever using the internet nor connecting to that computer.

It can be used to study alien life and alien civilizations.

It can be used to study the past or the future and even the present of any planet not just earth in the universe.

It can be used to find past lost technology or future unknown technology.

It can be used for just about anything where information is concerned with the past, present, future, and alternate time-lines.

It can be used as a temporal communication system.

It can be used as a temporal threat detection system.

Well that is enough for today. I am going to go work on my time travel computer code for the public. I will be making a post update soon. 

Reactor1967 over and out.     

-------------------------------------------------------------------------------------------------------------------

Off topic I watched space X planned Mars colonization. Musk thinks this will protect mankind. Not really, but it will help. But, if earth ever goes into world war III and America has a Mars colony. Russia or china will just lob a few nuclear missiles their way. And Russia knows how to build a damn big hydrogen bomb. No matter how deep in the ground that Mars colony is they won't have a fucking chance. That mars colony is no safer on Mars that a city on earth if or when war breaks out. Mutually assured destruction works just as well in outer space as it does on earth.

But, I still think spaceX should try. Mars would be protected from earths super volcano's but Mars would not be protected from asteroids or comets. A colony on Mars would still have its survival challenges.

And another thing if the Russians had the money the Americans have they would probably already be on the moon and Mars.

If America is going to put up a Mars colony and a moon colony they had better hurry the hell up. Because when the Russians and the Chinese get there they will claim the WHOLE DAMN PLANET AS THEIR OWN!!! And, I am not joking or playing around here. The Chinese or the Russians get a colony on Mars first and people will have to go through their embassy to get permission to land. And if they do they will be told where and when they can land. They will be escorted around. Then told to "GET OFF THEIR FUCKING PLANET". 

Shit you think the Arctic or the South China sea is a issue. Just wait till Russia and China start establishing off world bases. The shit will hit the fan then.

Russia, China, India, and other countries will claim half the damn asteroid belt as their own. American space mining companies will be shit out of luck.

You got to understand what ever country gets control of the asteroid belt will be the major super power on earth. America's days as the dominate super power are coming to an end. So, if America wants to stay a super power they had better hurry the hell up with space colonization.

Space may solve material problems for mankind but if or when mankind moves to space their problems will go with them.

Yeah Space X you had better hurry the hell up. Russia, China, India, and the rest of the world are on your ass.

Oh the next century is going to be so fun. I wish I could live that long to see it.

My advice for the American government is to give contracts priority to American companies that will advance America's interest in outer space. That means space X should have all the government contracts they can handle so they have enough money to finish that Mars colony.

Space mining companies should also be included in this.

Any American company providing products or services to outer space should be getting awarded all the government contracts they can handle.

And, it would not hurt to take that black budget and channel some public funding their way too. 

Cause when other countries get to outer space and if they do that first you may not be able to get a Space X rocket into Mars orbit without getting it shot down!!!!!!

You may not be able to go to the asteroid belt without having the Russians and the Chinese blowing up anything they consider entering their territory. 

My advice to my government you want to get America in space first because when other countries get there all hell is going to break loose.

There will be no "SAFETY" in outer space. There will be no "UTOPIA" in outer space. In fact Musk Mars colony will belong to the super rich. The rich will migrate to outer space like in the movie Elysium. Earth will become a place for factories, ghetto's, unemployment, and poverty.   

I see a time when even the governments on earth move their seats of power to outer space. If we can hold off world war three and the apocalypse for a while and colonize space things will radically change for mankind. But the power struggles and the threat of wars will still remain.

The safety that Musk spoke of is just a grand illusion and will not exist. The safety Musk spoke of is a pipe dream.

Mr. Musk my advice for you is to take that every two year launch window and throw it in the trash. Launch rockets two at a time for Mars. 

One rocket will contain people the other will contain food and supplies. They can go between ships to get what they need.

How ever long it takes to get to mars is what it is. Cause if other countries get the hint that their loosing out they ain't going to play around. The countries that snooze will loose BIG TIME. The future is fast approaching. 

I would start launching them rockets now and as often as needed. One or two cargo transports and the one with people. 

So what if it will take a little longer. That waiting to colonize space is bull shit.

The last country up there will be the looser. If America does not colonize space first there may not be a planet or asteroid left that American's can land on. America will have to build space stations instead. And that is if the space they build them in are not claimed by some other nation on earth. 

In conclusion resources, and space will become extremely valuable once space colonization begins. Every country will fight for that territory and mining rights. The country that controls most of that will be the dominate power in the solar system and on earth.
-----------------------------------------------------------------------------------
PUBLIC VERSION OF MY TIME TRAVEL SOFTWARE UPDATE. ENJOY

//*****************************************Copyright C Lloyd Burris aka Reactor1967 (TIME TRAVELER) 2008 TO 2016********************************
//*****************************************THIS IS A GENERAL OUTLINE FOR MY C++ CODE THAT I USE TO TIME TRAVEL WITH************************************
// Use >
// and < around includes
#include cstdlib
#include iostream
#include stdlib.h
#include fstream
#include sstream
#include string
#include cmath
#include ctime
#include cstdio
#include iostream

#include /home/reactor1967/mersennetwister.h> // This is a dependancy.

long long digitsoverzero1; // Use to control counter speed. Global variable
long long digitsoverzero2; // Use to control counter speed. Global variable

using namespace std;

// sub-routines

// Roll counter
int rollcounter(string file1, string file2, long long filesize1)
{
// roll counter <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< BEGIN ROLLING COUNTER
// declare variables
     long long count1 = 0;
     long long count2 = 0;
     int carry = 0;
     unsigned char buffer;
     char pause;
     int byte1;
     int byte2;
     int byte3;
     long long begin1;
     long long begin2;
     int buffersize = 1;


// add speed.bin byte(s) to counter
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Begin Add <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
// start count1 and count2
     count1 = -1;
     count2 = -1;

// set carry to 0
     carry = 0;

// open counter bin file
// open file
     fstream myfile1(file1.c_str(), ios::out  | ios::in | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "error in line 54" << " " << file1 << "\n";
          cin >> pause;
          exit(1);
     }

// open speed bin file
// open file
     fstream myfile2(file2.c_str(), ios::out  | ios::in | ios::binary);
     if (!myfile2)
     {
          myfile2.close();
          cout << "error in line 65" << " " << file2 << "\n";
          cin >> pause;
          exit(1);
     }

// start do loop
     do
     {
// increment count1
          count1++;
// increment count2
          count2++;

// read byte 1
          myfile1.seekg(count1);
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellg();
          byte1 = (int)buffer;
          if (count1 > digitsoverzero1)
          {
               digitsoverzero1 = count1;
          } 

// Read byte two
          myfile2.seekg(count2);
          myfile2.read( reinterpret_cast( &buffer ),buffersize);
          begin2 = myfile1.tellg();
          byte2 = (int)buffer;
          if (count2 > digitsoverzero2)
          {
               digitsoverzero2 = count2;
          }
                    
// add bytes byte3 = byte2 + byte1 + carry;
          byte3 = byte2 + byte1 + carry;

// set carry to 0
          carry = 0;

// if byte3 > 256 byte3 = byte3 - 256, carry = 1
          if (byte3  >= 256)
          {
                         
               byte3 = byte3 - 256;
               carry = 1;
          }
  
// write byte3
          buffer = (unsigned char)byte3;
          myfile1.seekp(count1);
          myfile1.write( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellp();
          
// end do loop for count1 < filesize1 - 1
     } while(count1 < filesize1 - 1);

// if carry == 1 do nothing so counter can roll over
     if (carry == 1)
     {
          // Do nothing 
     }

// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< End Add <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  
// close files
          myfile1.close();
          myfile1.clear();
          myfile1.flush();

          myfile2.close();
          myfile2.clear();
          myfile2.flush();

// End roll counter <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< END ROLLING COUNTER
     return(0);
}

// int setspeed
int setspeed(string file1, string file2, int speedspeed, long long counterspeed, long long filesize1) // Note speedspeed is from 1 to 255
{
     // NOTE I AM USING MULTIPLICATION IN BASES TO INCREASES THE SPEED.BIN FILE IN MULTIPLES OF BASE - 1
     // DEBUG THIS ROUTINE!!!!!!!!!!!!!!!!!!!!!!!!!!
     // declare variables
     long long count1 = -1; // counter speed loop
     long long count2 = -1; // speed speed loop
     long long count3 = -1; // temp.bin loop
     int byte = 0;
     long long begin1 = 0;
     long long begin2 = 0;
     int buffersize = 1;
     int byte1 = 0;
     int byte2 = 0;
     int carry = 0;
     int base = 256; // If you want to make this variable put this in the arguments
     char pause;
     unsigned char buffer;

     // This subroutine is all we are going to need for creating speed.bin and making it a specific size.

     // Here we are going to create a empty speed.bin file with 1 byte the size of the counter.
     // open speed.bin (open for input in binary)
     // open speed.bin for out
     fstream myfile1(file1.c_str(), ios:: out | ios:: binary);
     if (!myfile1)
     {
          cout << "Error in line 75 view vile.\n";
          cin >> pause;
          myfile1.close();
          myfile1.clear();
          myfile1.flush();
          exit(1); // terminate with error
     }

     // write 255 to space 0
     count3 = 0;
     byte = 255;
     buffer = (unsigned char)byte;
     myfile1.seekp(count3);
     myfile1.write( reinterpret_cast( &buffer ),buffersize);
     begin1 = myfile1.tellp();
     
     do
     {
          // increment count3
          count3++;

          // write 0 to rest of file
          byte = 0;
          buffer = (unsigned char)byte;
          myfile1.seekp(count3);
          myfile1.write( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellp();

     } while(count3 < filesize1 - 1);
     count3 = -1;
               
     // close files
     myfile1.close();
     myfile1.clear();
     myfile1.flush();     

     // Start counter speed loop
     // set count1
     count1 = -1;
     do
     {
          // increment count1
          count1++;

          // open temp.bin
          fstream myfile2(file2.c_str(), ios:: out | ios:: binary);
          if (!myfile2)
          {
               cout << "Error in line 32 view vile.\n";
               cin >> pause;
               myfile2.close();
               myfile2.clear();
               myfile2.flush();
               exit(1); // terminate with error
          }

          // create temp.bin which is size of counter filled with zeros (open for output in binary)
          // start temp.bin loop
          // set count3
          count3 = -1;
          do
          { 
               // Increment count3
               count3++;

               // write 0 to file for count
               byte = 0;
               buffer = (unsigned char)byte;
               myfile2.seekp(count3);
               myfile2.write( reinterpret_cast( &buffer ),buffersize);
               begin2 = myfile2.tellp();
   
          // repeat for count < filesize1 - 1
          } while(count3 < filesize1 - 1);

          // open speed.bin (open for input in binary)
          fstream myfile1(file1.c_str(), ios:: in | ios:: binary);
          if (!myfile1)
          {
               cout << "Error in line 129 view file.\n";
               cin >> pause;
               myfile1.close();
               myfile1.clear();
               myfile1.flush();
               exit(1); // terminate with error
          }
          // Here we start multiplication of speed.bin file to set the speed.
          // start file loop
          carry = 0; 
          count2 = -1;
          do
          {
               // increment count2
               count2++;

               // read byte 1 from speed.bin
               myfile1.seekg(count2);
               myfile1.read( reinterpret_cast( &buffer ),buffersize);
               begin1 = myfile1.tellg();
               byte1 = (int)buffer;

               // NOTE CARRY AND BYTE2 ARE USING MULTIPLICATION IN DIFFERENT NUMBER BASES

               // byte2 = (byte1 * speedspeed) - int((byte1 * base) / base);
               byte2 = (byte1 * speedspeed) - int(((byte1 * speedspeed) / base) * base) + carry;
               
               // carry = (multiply byte by speedspeed / base) 
               carry = int((byte1 * speedspeed) / base); // speedspeed can not be greater than 255
              
               // write to temp file at count subtract (byte * speed) - int((byte * speed) / base)
               buffer = (unsigned char)byte2;
               myfile2.seekp(count2);
               myfile2.write( reinterpret_cast( &buffer ),buffersize);
               begin2 = myfile2.tellp();
     
          // repeat loop for filesize1 - 1
          } while(count2 < filesize1 - 1);

          // close files
          myfile1.close();
          myfile1.clear();
          myfile1.flush();

          myfile2.close();
          myfile2.clear();
          myfile2.flush();

          // delete speed.bin
          system("rm speed.bin");

          // mv temp.bin to speed bin
          system("mv temp.bin speed.bin");

     // End loop for counter size
     } while(count1 < counterspeed);

     // return(0);
     return(0);    
}
// ========================================================================================================

// int viewfile1
// ==========================================================================
int viewfile1(string file1, long long filesize1, int buffersize)
{
     int count = -1;
int byte1 = 0;
     long long begin1 = 0;
unsigned char buffer(buffersize);
string pause;
// open file 1
     fstream myfile1(file1.c_str(), ios:: in | ios:: binary);
     if (!myfile1)
     {
          cout << "Error in line 314 view file.\n";
          cin >> pause;
          myfile1.close();
          myfile1.clear();
          myfile1.flush();
 exit(1); // terminate with error
     }

do
{
     count++;

  // read file 1
          myfile1.seekg(count);
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellg();
          byte1 = (int)buffer;
 cout << " count " << count << " " << " byte " << byte1 << "\n";

} while (count < filesize1 - 1);


// close file1
// close file2
     myfile1.close();
     myfile1.clear();
     myfile1.flush();

     return(0);


}
// ==============================================================================

// int binaryreadwrite
// =============================================================================
int binaryreadwrite(string whatdo, string file1, long long byteposition, int byte)
{

     unsigned char buffer;
     char pause;
     int byte1 = byte;
     long long count1 = byteposition;
     long long begin1;
     int buffersize = 1;
       
     // open file
     fstream myfile1(file1.c_str(), ios::out  | ios::in | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "error in line 266" << " " << file1 << "\n";
          cin >> pause;
          exit(1);
     }
     if (whatdo == "read")
     {
// cout << byte1 << " We are reading bytes " << "\n"; // debug code
          myfile1.seekg(count1);
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellg();
          byte1 = (int)buffer;
          myfile1.close();
          myfile1.clear();
          myfile1.flush();
          return(byte1);
     }
     if (whatdo == "write")
     {
// cout << byte1 << " We are writing bytes " << "\n"; // debug code
          buffer = (unsigned char)byte1;
          myfile1.seekp(count1);
          myfile1.write( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellp();
          myfile1.close();
          myfile1.clear();
          myfile1.flush();
          return(0);
     } 
     

     cout << "Error in binary read and write" << "\n";
     cin >> pause;
     exit(1);
     return(0);
}

// ==============================================================================
// ==============================================================================
int createcounterfile(string file1, long long checksum, long long filesize1)
{
// delcare variables
     string pause;
     int byte = 0;
     int count = 0;
     int weak1 = checksum;
     int test = 0;
     unsigned char buffer;
     int buffersize = 1;
     long long begin1 = 0;

    // open file1
     fstream myfile1(file1.c_str(), ios::out | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one Line 141.\n";
          cin >> pause;
          exit(1);
     }

// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Bringing counter to weak check sum
   // start loop at 0
            count = -1;  
          do // THIS IS NOT THE COUNTER HERE. I BRING COUNTER TO A SPECIFIC WEAK CHECKSUM NOT ROLL IT.
          {
               count++;    

   // test if weak check sum - 255 > 0
               if (weak1 - 255 >= 0)
               {
                    test = 1;
               }
               else
               {
                    test = 0;
               } 

   // if test is yes write to byte 255
   // if test is yes subtract 255 from weak1
               if (test == 1)
               {
                    byte = 255;
                    buffer = (unsigned char)byte;
                    myfile1.seekp(count);
                    myfile1.write( reinterpret_cast( &buffer ),buffersize);
                    begin1 = myfile1.tellp();
                    
                    weak1 = weak1 - 255;
                    if (weak1 < 0)
                    {
                         weak1 = 0;
                    }
                    
               }

   // if test is no byte = weak1
   // if test is no subtract byte from weak1   
   // if test is no write byte to file
   
               if (test == 0)
               {
                    byte = weak1; 
                    weak1 = weak1 - byte;
                    if (weak1 < 0)
                    {
                         weak1 = 0;
                    }                    
                    buffer = (unsigned char)byte;
                    myfile1.seekp(count);
                    myfile1.write( reinterpret_cast( &buffer ),buffersize);
                    begin1 = myfile1.tellp();
               }

// end create counter file when weak2 = 0
          } while(count < filesize1 - 1);
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Done bringing counter to weak check sum

     myfile1.close();
     myfile1.clear();
     myfile1.flush();
     return(0);

}
// ==============================================================================

// long double getstrongchecksum1 (for random strong check sums)
// =======================================================================================
long double getstrongchecksum1(string file1, int buffersize, int howmanyweightedsums)
{
//     cout << "Getting weighted check sum\n";
     long double schecksum;
     int byte1 = 0;
     long long count = -1;
     long long count2 = 0;
     long long filesize1 = 0;
     long long begin1 = 0;
     long long end1 = 0;
     long long seednumber = 0;
     unsigned char buffer(buffersize);
     long double x1 = 0;
     long long x2 = 0;
     MTRand mtrand1a( 5654940 );
     string pause;
     

     // open file1
     fstream myfile1(file1.c_str(), ios::in | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line 178.\n";
          cin >> pause;
          exit(1);
     }

// get filesize1
     begin1 = myfile1.tellg();
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line 188.\n";
          cin >> pause;
          exit(1);
     }
     myfile1.seekg (0, ios::end);
     end1 = myfile1.tellg();
     filesize1 = (end1-begin1);

     mtrand1a.seed(5654940);
     count = 0;
     schecksum = 0;
do
     {

          byte1 = 0;
// read file1
          myfile1.seekg(count);
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellg();
          byte1 = (int)buffer;
          count2 = 0;
     do
          {
               count2++;
      x1 = mtrand1a.randExc(.9999999);
//               weightedsumarray2[count] = weightedsumarray2[count] + (byte1 * x1);
                 schecksum = schecksum + (byte1 * x1);
          } while(count2 < howmanyweightedsums);
//           schecksum = schecksum + weightedsumarray2[count];
      count = count + buffersize;
     } while (count < ((filesize1 - 1) + buffersize));

     myfile1.close();
     myfile1.clear();

     return(schecksum);

}
// ==============================================================================

// long double getstrongchecksum2 (for left to right with linear numerical weights. .1,.2,.3,.3....)
// =======================================================================================
long double getstrongchecksum2(string file1, int buffersize, int howmanyweightedsums)
{    // This uses linear weights .1,.2,.3.... so forth.
//     cout << "Getting weighted check sum\n";
     long double schecksum;
     int byte1 = 0;
     long long count = -1;
     long long count2 = 0;
     long long filesize1 = 0;
     long long begin1 = 0;
     long long end1 = 0;
     long long seednumber = 0;
     unsigned char buffer(buffersize);
     long double x1 = 0;
     long long x2 = 0;
     long double mtrand1a = 0;
     string pause;     

     // open file1
     fstream myfile1(file1.c_str(), ios::in | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line 178.\n";
          cin >> pause;
          exit(1);
     }

// get filesize1
     begin1 = myfile1.tellg();
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line 188.\n";
          cin >> pause;
          exit(1);
     }

     myfile1.seekg (0, ios::end);
     end1 = myfile1.tellg();
     filesize1 = (end1-begin1);
     
     count = 0;
     schecksum = 0;
     mtrand1a = 0;
     do
     {
      
          byte1 = 0;
// read file1
          myfile1.seekg(count);
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          begin1 = myfile1.tellg();
          byte1 = (int)buffer;
          count2 = 0;
          do
          {
               count2++;
      mtrand1a = mtrand1a + .00001;         
               x1 = mtrand1a;
//               weightedsumarray2[count] = weightedsumarray2[count] + (byte1 * x1);
               schecksum = schecksum + (byte1 * x1);
          } while(count2 < howmanyweightedsums);
//           schecksum = schecksum + weightedsumarray2[count];
      count = count + buffersize;
     } while (count < ((filesize1 - 1) + buffersize));

     myfile1.close();
     myfile1.clear();
     myfile1.flush();

     return(schecksum);

}
// ==============================================================================

// long long weakchecksum
// =======================================================================================
long long weakchecksum(string file1, int buffersize) // For some reason will not take buffer size. Debug - FOR NOW MANUALLY ENTER BUFFER SIZE THEN COMPILE.
{
     fstream myfile1;
     int x;
     int buffersize2 = buffersize;
     long long checksum = 0;
     long long begin1;
     long long count1;
     long long count2;
     unsigned char buffer(buffersize2);
     long long size1;
     long long size2;
     long long filesize;
     string pause;

     myfile1.open(file1.c_str(), ios:: in | ios:: binary);
     if (!myfile1)
     {
          cout << "122608-12:02 am Unable to open file.\n";
          cin >> pause;
          exit(1); // terminate with error
     }

     myfile1.seekg(0, ios::beg);
     size1 = myfile1.tellg();
     myfile1.seekg(0, ios::end);
     size2 = myfile1.tellg();
     filesize = size2 - size1;

     count1 = 0;
     do
     {

          begin1 = myfile1.tellg();
          myfile1.seekg(count1);
          if (!myfile1)
          {
               myfile1.close();
               cout << "error in line 51.\n";
               cin >> pause;
               exit(1);
          }
          myfile1.read( reinterpret_cast( &buffer ),buffersize);
          x = (int)buffer;

          checksum = checksum + x;
          count1 = count1 + buffersize2;

     } while (count1 <  ( ( filesize - 1 ) + buffersize2 ) );

     return(checksum);
}
// =======================================================================================

// long long filesize
// ==============================================================================
long long filesize(string file1)
{
//    cout << "Get file size.\n";
    long long begin1;
    long long end1;
    long long filesize1;
    string pause;

    // open file1
     fstream myfile1(file1.c_str(), ios::in | ios::binary);
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line306.\n";
          cin >> pause;
          exit(1);
     }

// get filesize1
     begin1 = myfile1.tellg();
     if (!myfile1)
     {
          myfile1.close();
          cout << "Failed to read file one line 316.\n";
          cin >> pause;
          exit(1);
     }
     myfile1.seekg (0, ios::end);
     end1 = myfile1.tellg();
     filesize1 = (end1-begin1);
     myfile1.close();
     myfile1.clear();
     myfile1.flush();
//     cout.precision(37);
//     cout << filesize1 << "\n";
     return(filesize1);
}
// ==============================================================================

// Start main
int main (int argc, char *argv[])
{

// Declare variables (Delete all these variables and compile to find out what needed and what not).
    char choice;
    char pause;
    int buffersize = 1;
    string file1 = "";
    string file2 = "";
    int howmanyweightedsums=0;
    long double scksum = 0;
    long double scksum2 = 0;
    long double diff1;
    long double diff2; 
    long long checksum;
    long long filesize1;
    string dummy = "";
    int dummyfile = 0;
    int rollbytes = 0;
    long long weak1 = 0;
    string whatdo;
    long long byteposition = 0;
    int byte;
    int test;
    long long count;
    long long count1;
    int rev = 0;
    long long bytepos;
    int byte1;
    int byte2;
    int byte3;
    long long count2;
    int dummybyte;
    int carry;
    long long carrypos1 = 0;
    long long rollpos1 = 0;
    long long rollpos2 = 1;  
    int abc = 0;
    long long filesize2 = 0;
    int revolutions;
    int counterspeed = 1;
    int setcounterspeed = 0;
    int speedspeed = 0;
    string direction = "+"; // This is the direction of the counter speed. + means increase speed. - means decrease speed.
    long long digitsoverzero1 = 0;
    long long digitsoverzero2 = 0;

// create menu 
    cout << "\n";

    // 1. Recreate file from check sum.
    cout << "1. Reconstruct computer file from checksum." << "\n";

    // 2. Create a configure file for single program.
    cout << "2. Create configure file for a single file." << "\n";

    // 3. Create time travel project config file.
    cout << "3. Create time travel project config file." << "\n";

    // 4. Run time travel project
    cout << "4. Run time travel project." << "\n";

    // 5. Manually create time travel project configure file
    cout << "5. Manually create time travel project configure file." << "\n";

    // 6. Manually create configure file for check sum hack. 
    cout << "6. Manually create configure file for checksum hack." << "\n";

    cin >> choice;

// if choice = 1.
    if (choice=='1')
    {
// Load configure file
          fstream c1myfile("filechecksumconfig.txt", ios::in);
   // read name of file
          c1myfile >>  dummy >> dummy >> dummy >> file1;
   // read weak check sum
          c1myfile >>  dummy >> dummy >> checksum;
   // read strong check sum 
          c1myfile >>  dummy >> dummy >> scksum;
   // read file size
          c1myfile >>  dummy >> dummy >> dummy >> filesize1;
   // read how man weights
          c1myfile >>  dummy >> dummy >> dummy>> dummy >> dummy >> howmanyweightedsums;
   // close configure file
          c1myfile.close();
          c1myfile.clear();
   // Print configure file to confirm loaded correctly
   // I have two strong check sum routines. Know which fucking one to use.
          cout << file1 << " file name\n ";
          cout.precision(36);
          cout << checksum << " weak check-sum\n ";
          cout.precision(36);
          cout << scksum << " strong check-sum\n ";
          cout.precision(36);
          cout << filesize1 << " file size\n";
          cout.precision(36);
          cout << howmanyweightedsums << " how many weighted check-sums\n";
          cout << "Is the configuration file loaded properly?" << "\n";
          cin >> pause;
    
// call create counter sub
          file1 = "counter.bin";
          dummyfile = createcounterfile(file1, checksum, filesize1); 

// Back up counter
          system("cp counter.bin counter.bak");

// Create speed.bin       
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Create speed.bin
          file1 = "speed.bin";
          file2 = "temp.bin";
          counterspeed = 0; // We start at 0 so this multiplied twice
          speedspeed = 1;
          dummyfile = setspeed(file1, file2, speedspeed, counterspeed, filesize1);
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< END Create speed.bin
   
// This is where all the business in performed.
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< BEGIN FILE CONSTRUCTION LOOP <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
          do
          {
               // get file size 1
               file1 = "counter.bin";
               filesize1 = filesize(file1);
               
               // get file size 2
               file2 = "speed.bin";
               filesize2 = filesize(file2);

               // get strong checksum 2 of counter 
               scksum2 = getstrongchecksum2(file1, buffersize, howmanyweightedsums);

               // diff1 = abs(checksum2 - checksum1)
               diff1 = abs(scksum2 - scksum);

// cout << " before we roll " << "\n";
// file1 = "counter.bin";
// dummyfile = viewfile1(file1, filesize1, buffersize);
// cin >> pause;
          
               // call roll counter
               file1 = "counter.bin";
               file2 = "speed.bin";    
               dummyfile = rollcounter(file1, file2, filesize1);             
               
// cout << " after we roll " << "\n";
// file1 = "counter.bin";
// dummyfile = viewfile1(file1, filesize1, buffersize);
// cin >> pause;


               // get weak check sum
               weak1 = weakchecksum(file1, buffersize);
               
               // Begin getting strong and weak destination and target check sums and measursements.########################
               // get strong checksum 2 of counter 
               scksum2 = getstrongchecksum2(file1, buffersize, howmanyweightedsums);
                    
               // diff1 = abs(checksum2 - checksum1)
               diff2 = abs(scksum2 - scksum);
               // End gettng strong and weak destination and target check sums and measurements.############################                   
// ******************************************** DO NOT DELETE THIS **********************************************************************
               // Put section here for setting the counter speed#############################################################
                // file1 = "speed.bin";
               // file2 = "temp.bin";
               // counterspeed++; // We start at 0 so this multiplied twice
               // speedspeed = 2;
               // dummyfile = setspeed(file1, file2, speedspeed, counterspeed, filesize1);
               // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< END setting counter speed
               
               // Put section here for determining what the counter speed should be#########################################
               if (digitsoverzero2 >= filesize1 - 1) // reverse direction of counter.                    
               {
                  //  file1 = "speed.bin";
                  //  file2 = "temp.bin";
                  //  counterspeed = 0; // We start at 0 so this multiplied twice
                  //  speedspeed = 1;
                  //  dummyfile = setspeed(file1, file2, speedspeed, counterspeed, filesize1);
               }                    
               // End determining what the counter speed sould be###########################################################
// **************************************************************************************************************************************                    

// if weak check sum within range
               if (weak1 == checksum)
               {   

               // Begin coping and restoring counter. #######################################################################
                    if (diff2 < diff1)
                    {
                          cout << " We are good " << "\n";  
                          // Keep counter. We are good.
                         // system("cp counter.bin counter.bak");
                    }
                   
                    if (diff2 > diff1)
                    {
                         cout << " Speed Violation " << "\n";
                         // cin >> pause;
                         // exit(0);
                         // delete counter and restore backup counter                         
                         // system("cp counter.bak counter.bin");
                    } 
               // End coping and restoring counter. ######################################################################### 

                    // View output of counter
//                    file1 = "counter.bin";
//                    cout << "\n";
//                    cout << " counter.bin " << "\n";
                    dummyfile = viewfile1(file1, filesize1, buffersize);
//                     cout << "\n";
//                    file2 = "speed.bin";
//                    cout << " speed.bin " << "\n";
//                    dummyfile = viewfile1(file2, filesize1, buffersize);
                    cout << "\n";
                    // cin >> pause;
                    

                    // Begin file construction complete.#########################################################################
                    if (diff2 == 0)
                    {
                         cout << "File Reconstructed" << "\n";
                         cin >> pause;
                         exit(0);
                    }
                    // End file construction complete.##########################################################################

               } // end if weakchecksum1 == weakchecksum

               if (weak1 != checksum) // This is when the counter is out of range. Nothing needed to do here.
               {
                    // View output of counter
                //    file1 = "counter.bin";
                //    cout << "\n";
                //    cout << " counter.bin " << "\n";
                //    dummyfile = viewfile1(file1, filesize1, buffersize);
                //    cout << "\n";
                //    file2 = "speed.bin";
                //    cout << " speed.bin " << "\n";
                //    dummyfile = viewfile1(file2, filesize1, buffersize);
                //    cout << "\n";
                    // cin >> pause;
                    

                    // Begin file construction complete.#########################################################################
                //    if (diff2 == 0)
                //    {
                //         cout << "File Reconstructed" << "\n";
                //         cin >> pause;
                //         exit(0);
                //    }
                    // End file construction complete.##########################################################################
               }

          // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< END FILE CONSTRUCTION LOOP <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
          } while(abc != 999); // End construction loop
          exit(0);                

     } // end if choice = 1;

// if choice = 2
     if (choice=='2')
     {
          // Get seed for random number generator          
          // MTRand mtrand1a( 5654940 );
     // ask user file name
          cout << "Please enter the name of your target file." << "\n";
          cin >> file1;
     // ask how many weights to use for strong check sum
          cout << "How many weighted sums are we using?" << "\n";
          cin >> howmanyweightedsums;
     // get file size
          filesize1 = filesize(file1);
     // get weak check sum
          checksum = weakchecksum(file1,buffersize);
     // get strong check sum // Know which routine to fucking use.
          scksum = getstrongchecksum2(file1, buffersize, howmanyweightedsums); 
          // scksum = getstrongchecksum1(file1, buffersize, howmanyweightedsums);
     // write to configure file
          fstream c1myfile("filechecksumconfig.txt", ios::out);
          if (!c1myfile)
          {
               cout << "Unable to open file line 402 \n";
               system("pause");
               exit(1); // terminate with error
          }
          c1myfile << " Name of file " << file1 << "\n";
          c1myfile.precision(36);
          c1myfile << " Weak checksum " << checksum << "\n";
          c1myfile.precision(36);
          c1myfile << " Strong checksum " << scksum << "\n";
          c1myfile.precision(36);
          c1myfile << " Size of file " << filesize1 << "\n";
          c1myfile << " How Many Weighted Checksums used " << howmanyweightedsums << "\n";
          // close files
          c1myfile.close();
          c1myfile.clear();
     // tell user config file created
          cout << "Config file created." << "\n";
          cin >> pause;
     // exit program
          exit(0);
     }

// if choice = 3
     // Ask user how many config files to generate
     // get list of media directory
     // create list of configure files from media directory list in one file

     // perform mathematical calulations to get regression line of strong and weak check sums
          // open configure file
          // start loop
          // perform calulation for regression line with strong check sums
          // calulate devations for strong check sums
          // perform caluation for regression line with weak check sums
          // caluate devations for weak check sums
          // perform caluation for regression line of file sizes
          // caluate devations for file sizes
     // end loop
  
  
     // create time travel configure file for regression line
          // write equation of line for strong check sums
          // write standard deviation for strong check sums
          // write equation of line for weak check sums
          // write standard deviation  for weak check sums
          // write equation of line for file sizes
          // write standard deviations for file size
          // close files
   // Inform user project finished
   // end program

// End choice 3

// if choice equals 4
     // load time travel configure file
     // load random number generator
     // start at bottom of regression line

     // start do loop
          // generate config file # of strong and weak check sums with file size from regression lines data
             // Generate strong check sum
             // Generate weak check sum
             // Generate file size
             // open file for config file # 1,2,3,4,5,6,7,8..............     
             // Write config file # 1,2,3,4,5,6,7,8.....................................
     // repeat loop until number of config files generated

     // start loop
          // load config file # 1,2,3,4,5,6,7,8................
          // call reconstruct for file # 1,2,3,4,5,6,7,8 ................... (This is where files are constructed from their checksums)
          // rename counter 1,2,3,4,5,6,7,8....................
     // repeat loop till all config files reconstructed

     // stort loop (Here the bots look at the time travel media to determine if the files are good or bad.)
     // call bot1 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot2 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot3 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot..................................
     // repeat loop for counter file # 1,2,3,4,5,6,7,8 till all counters look at by time travel bots
     // Notify user time travel program completed (At this point the user looks at the good and suspicious time travel media.
     // From here the user can go back to the configure list and manually create configure files to help clear up grainy files.)
     // Exit program

// if choice equals 5
     // Ask user for equation of regression line for strong check sums
     // Ask user for high standard devation line for strong check sums
     // Ask user for low standard devation line for strong check sums
     // Ask user for equation of regression line for weak check sums
     // Ask user for high standard devatin line for weak check sums
     // Ask user for low standard devation line for weak check sums
     // Ask user for equation regression line of file sizes
     // Ask user for high standard devation of file size
     // Ask user for low standard devation of file sizes 
     // open file to write configure file
     // write configure file
     // close configure file
     // exit program

// if choice equals 6
   // ask user for file size
   // ask user for strong check sum
   // ask user for weak check sum
   // open file to write configure file
   // write configure file
   // close configure file

}

------------------------------------------------------------------------------------------

Here is my traffic for today.





-----------------------------------------------------------------------------

Well everyone don't get too comfortable with that outline update I just posted  because it is going to change. For the public version of my code I am going to paralyze the binary counter. I am going to break it down into 1 counter for every three or 4 bytes of file size. I am only going to have 1 thread though running all the counters. If the public wants more they can put those changes in for themselves.

My code is beginner learner code for time travel with computers. I will get it working and then the public can take it from there.

I will leave the routine in that can save the entire counter.bin when it is closer to its target and delete it and restore the back up when it is farther away from its target. If that works with a parallel counter great if not I will comment it out and leave it in case the user wants to experiment with it.

I am  commenting out my counter speed section.

Since I am running a parallel counter each section of the counter will be incremented by 1 minus the base. The base being 256. In my more advanced private code my base is my buffer size. And I use a very advanced algorithm for rolling my counter. It is much faster than what I am using for my public version of my code. It also works nicely for throttling my counter. But for the public version it would be way to complicated for most people to understand.

So, I want to keep my public version of my code as simple as possible. I want to demonstrate and teach my principles of time travel with computers. And I can't teach if I go over my students heads. My own private code is a monster from hell. At least people can read and understand my public version of my code. Well at least the programmers can anyway.

From there I will move to completing the rest of the program outline. My goal is to give the world a public version of my code they can play with and use to time travel with like I do. I will leave as many options in the code as possible and let the public choose what they want to compile in or leave out.


When the public version of my code is finished it will be simple, elegant, easy to use, AND IT WILL FUCKING WORK!!!

When I time travel with my computer I have a program and I go in and choose what options I want with each time travel project. I then compile my code and run my project. So, with posting my code and directions how to compile it I am teaching the public to time travel the way I do.


I will have the code in a easy to use default version that the public can use. If I have features that are useful I will leave them commented out. I will remove features that prove useless in this version of my code.

So, for my star gate chevron locking mechanism of my code I will have the paralyzed counter rolling. As each baby counter in the entire counter comes into sync with the target strong check sum this will be my chevron.

I will be deleting or commenting out the saving and backing up of the counter depending on how testing goes with the final version of my public code.

As the baby counters come into sync they can be locked down and not rolled anymore. But, in testing I will look at all that. But for sure all the baby counters will be added up to complete the entire time travel media file being constructed. Each baby counter though will be a chevron locking in and bringing into my time line information from the past, present, future, and other time lines.

I will teach the public to explore the universe, the multi-verse this way. I will teach the public to hack gods computer and use it like  they fucking own it. They won't even have to know how to program. I will show them how to comment in sections of code they want to use and comment out sections of code they don't won't then compile and run. NO PROGRAMING EXPERIANCE REQUIRED. JUST COMMENT IN AND COMMENT OUT. LIKE A SCRIPT KIDDY. LIKE AARON HINIKER DOES.

This time travel computer code I am bringing to the public will be much more simple and elegant to use plus IT CAN BE USED ON A PARALLEL COMPUTER. TIME TRAVEL ONE STATION WOULD RUN THE HELL OUT OF THIS CODE.

So, I will get those changes made.

When I get the counter paralyzed in the public version and running it will work more closely like my own more advanced code but will be much simpler to use. 

I am looking forward to moving on with this outline and getting it finished for the public to use. Then I will work on getting it updated. I WILL BE POSTING THIS AT SOURCEFORGE. IT WILL BE OPEN SOURCE.


I still have the CIA and NSA and the "Conspiracy Against Time Travel to contend with. So, my problems are not over. The more I talk to the public about this and help the public the more these mother fuckers are on my ass. I'm pretty sure these guys know what I had for breakfast, lunch, and dinner. When I take a shit or a piss. And everything else about my personal life.

Fuck them. That is all I have to say about the matter. My status as a time traveler ensures this ass holes will be watching me the rest of my natural fucking life. At least I am not at Gitmo.

---------------------------------------------------------------------------------------------------------------------

I am starting a new file for my new outline. I will leave my old code up. The paralyzing the counter will do the trick with the public version of my time travel code. The "Conspiracy Against Time Travel" will be PISSED OFF NOW. I find that rather funny. 

Here is how the new program outline will look. I am putting in the code now. I may some small changes here and there.

//*****************************************Copyright C Lloyd Burris aka Reactor1967 (TIME TRAVELER) 2008 TO 2016********************************
//*****************************************THIS IS A GENERAL OUTLINE FOR MY C++ CODE THAT I USE TO TIME TRAVEL WITH************************************
// put < in front of include names
// put > behind include names
#include cstdlib
#include iostream
#include stdlib.h
#include fstream
#include sstream
#include string
#include cmath
#include ctime
#include cstdio
#include iostream
#include /home/reactor1967/mersennetwister.h // This is a dependancy.

using namespace std;

// sub-routines
// ==========================================================================
// Roll counter
// ==========================================================================
int rollcounter(string file1, string file2, long long filesize1)
{
     // Run counter 1 exit, run counter 2 exit, run counter 3 exit........
}
// ==========================================================================
// int viewfile1
// ==========================================================================
int viewfile1(string file1, long long filesize1, int buffersize)
{
     // print byte 1, print byte 2, print byte 3, print byte 4......
}
// ==========================================================================
// int createcounterfile
// ==========================================================================
int createcounterfile(string file1, long long checksum, long long filesize1)
{
     // open counter file
     // bring counter file to weak check sum
     // close counter file
     // exit
}
// ==========================================================================
// long double getstrongchecksum1 (for random strong check sums)
// ==========================================================================
long double getstrongchecksum1(string file1, int buffersize, int howmanyweightedsums)
{
     // read byte
     // get weight
     // multiply byte by weight
     // add bytes up
}
// ==========================================================================
// long long weakchecksum
// ==========================================================================
long long weakchecksum(string file1, int buffersize) // For some reason will not take buffer size. Debug - FOR NOW MANUALLY ENTER BUFFER SIZE THEN COMPILE.
{
     // weak check sum equals Add byte1 + byte2 + byte3 + byte4 + byte5
}
// ==========================================================================
// long long filesize
// ==========================================================================
long long filesize(string file1)
{
     // get file size of file
}
// ==========================================================================
// int binaryreadwrite
// ==========================================================================
int binaryreadwrite(string whatdo, string file1, long long byteposition, int byte)
{
     // open file for binary read and write
     // Read and write binary data to and from file
     // close binary file
}

// Start main
int main (int argc, char *argv[])
{
// Declare variables 
// create menu 
    // print space

    // 1. Recreate file from check sum.

    // 2. Create a configure file for single program.

    // 3. Create time travel project config file.

    // 4. Run time travel project

    // 5. Manually create time travel project configure file

    // 6. Manually create configure file for check sum hack. 

    // Enter Choice

    // if choice == 1
         // Load configure file
         // read name of file
         // read weak check sum
         // read strong check sum 
         // read file size
         // read how man weights
         // close configure file
         // Print configure file to confirm loaded correctly
         // call create counter sub
         // Begin file construction loop
              // call roll counter
              // get file size 1
              // get file size 2
              // get strong checksum 
              // diff1 = abs(checksum2 - checksum1) 
              // if diff1 == 0
                   // print file reconstructed      
                   // pause program
                   // exit program
         // End file construction loop
    // End if choice == 1

    // if choice == 2
         // Get seed for random number generator          
         // ask user file name
         // ask how many weights to use for strong check sum
         // get file size
         // get weak check sum
         // get strong check sum // Know which routine to fucking use.
         // scksum = getstrongchecksum2(file1, buffersize, howmanyweightedsums);
         // write to configure file
         // open file
         // write name
         // set precision to 36
         // write weak check sum
         // set precision to 36
         // write strong check sum
         // set precision to 36
         // write size of file
         // write how many weighted check sums
         // close files
         // tell user config file created
         // exit program
    // End if choice == 2 

// if choice = 3
     // Ask user how many config files to generate
     // get list of media directory
     // create list of configure files from media directory list in one file

     // perform mathematical calculations to get regression line of strong and weak check sums
          // open configure file
          // start loop
          // perform calculation for regression line with strong check sums
          // calculate deviations for strong check sums
          // perform calculation for regression line with weak check sums
          // calculate deviations for weak check sums
          // perform calculation for regression line of file sizes
          // calculate deviations for file sizes
     // end loop
  
  
     // create time travel configure file for regression line
          // write equation of line for strong check sums
          // write standard deviation for strong check sums
          // write equation of line for weak check sums
          // write standard deviation  for weak check sums
          // write equation of line for file sizes
          // write standard deviations for file size
          // close files
   // Inform user project finished
   // end program
// End choice 3

// if choice equals 4
     // load time travel configure file
     // load random number generator
     // start at bottom of regression line

     // start do loop
          // generate config file # of strong and weak check sums with file size from regression lines data
             // Generate strong check sum
             // Generate weak check sum
             // Generate file size
             // open file for config file # 1,2,3,4,5,6,7,8..............     
             // Write config file # 1,2,3,4,5,6,7,8.....................................
     // repeat loop until number of config files generated

     // start loop
          // load config file # 1,2,3,4,5,6,7,8................
          // call reconstruct for file # 1,2,3,4,5,6,7,8 ................... (This is where files are constructed from their check-sums)
          // rename counter 1,2,3,4,5,6,7,8....................
     // repeat loop till all config files reconstructed

     // start loop (Here the bots look at the time travel media to determine if the files are good or bad.)
     // call bot1 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot2 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot3 to look at counter file # 1,2,3,4,5,6,7,8
     // call bot..................................
     // repeat loop for counter file # 1,2,3,4,5,6,7,8 till all counters look at by time travel bots
     // Notify user time travel program completed (At this point the user looks at the good and suspicious time travel media.
     // From here the user can go back to the configure list and manually create configure files to help clear up grainy files.)
     // Exit program
// End if choices equals 4

// if choice equals 5
     // Ask user for equation of regression line for strong check sums
     // Ask user for high standard deviation line for strong check sums
     // Ask user for low standard deviation line for strong check sums
     // Ask user for equation of regression line for weak check sums
     // Ask user for high standard deviation line for weak check sums
     // Ask user for low standard deviation line for weak check sums
     // Ask user for equation regression line of file sizes
     // Ask user for high standard deviation of file size
     // Ask user for low standard deviation of file sizes 
     // open file to write configure file
     // write configure file
     // close configure file
     // exit program
// end if choice equals 5

// if choice equals 6
   // ask user for file size
   // ask user for strong check sum
   // ask user for weak check sum
   // open file to write configure file
   // write configure file
   // close configure file 
// end if choice equals 6

// exit program

}

Well I got it written and compiled. That did not take long. Here is the video. But, its not finished yet. Now I have to use my algorithm for getting my strong check-sums of an entire file and have it break that that down into smaller strong check sums for each baby counter within the entire file. 

In the video below I have a 8 byte file and I am running two 4 byte counters within the file. 

Each counter is my Chevron like on the movie star gate. I have to assign each baby counter its own strong check sum. 

Then, as those baby counters run when they hit their own strong check sum they stop rolling. Thus locking down that chevron and coming a step closer to bringing information from the past or future into my existence as a time travel media computer file.

With my weighted sums and the weights within those weighted sums I can write a sub-routine that will calculate each baby counters strong check sum.

When I go to find time travel media with this method I can take my algorithms and weights and using the strong check sum for the entire file I can calculate the baby strong check sums for each baby counter. I will have to re-write my routine to make a config file and put that in my config file. When that config file is loaded so will the check sums for my baby counters. OK, here is the short video. I am done for today. Tomorrow I will start re-writing my config routine and I will have to add code into my construct routine.