Showing posts with label Einstein. Show all posts
Showing posts with label Einstein. Show all posts

Monday, February 20, 2017

COMPUTER TIME TRAVEL ON THE LINUX COMMAND LINE.

02/20/2017 04:22 AM

I have been writing my programs in c++ but it is possible to do a lot of what I do without my computer code on the Linux command line. Using Linux command line tools files can be converted to higher bases and piped to text files. People can make text files with numbers in a specific base and using the Linux command line write that test file to a binary file. Also using Linux commands  and scrpts files can be added to or subtracted from in base math just like I do in my c++. Linux has plotting utilities to plot regression lines. I am able to do most of my stuff on the command line without writing scripts by using echo and cat and less and piping from one command to the other.

So, I am including examples in time travel project. I don't have a update yet.

But here are some examples of Linux.


These are the list of linux commands I can run on my system.



To get these commands use "compgen -c > commands.txt" without the quotes.

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

The most command commands I use are
file - "This checks file formats"
aspell - "Spell check text files"
split - "This splits files up"
cat - This gives whats in a file or can be used to join files USE CAT /DEV/RANDOM > random.bin for true random numbers
cksum - counts the bytes in a file.
join - joins files
nl - number of lines in a file.
shred-over write a file
echo 'obase=2; ibase=10; 674238' | bc - converts decimal to binary 
bc - can be used to perform mathematical operations on the command line. 
less - display content of long files
dd - reads binary files writes binary files
----------------------------------------------------------------
reverse hex dump
echo 'ibase=16' | cat - hdump | tr ' ' \; | bc | awk '{printf("%c",$0)}'
ABCDEFGH
----------------------------------------------------------------
For the lottery program get your lottery data base this way.
remote file

lynx --dump www.google.com > file.txt
links -dump www.google.com
local file

lynx --dump ./1.html > file.txt
links -dump ./1.htm

I convert news from news web-sights this way to search for
news from the future with my software.
----------------------------------------------------------------
To rip a websight in Linux
$ wget \
     --recursive \
     --no-clobber \
     --page-requisites \
     --html-extension \
     --convert-links \
     --restrict-file-names=windows \
     --domains website.org \
     --no-parent \
         www.website.org/tutorials/html/
----------------------------------------------------------------
Display output as decimal integers (Convert binary files to numbers)
$ od -i input
0000000   171051569   171182643   171313717   171444791
0000020   808520249   170995978   822751793   875629107
0000040   171258122   822752817   942737975   171520266
0000060      667698
0000063
----------------------------------------------------------------
When converting files from one base to the other you have to
echo the file.

xxd test.bin > test.txt - converts binary to base 8 numbers

echo "$( test2.bin converts base 8 numbers back to binary
----------------------------------------------------------------
You can use the dd command to read a computer file and pipe it
to ibase and obase to convert the file to another base and write it to a text file.

You can echo a text file and pipe it to ibase and obase to conver the file then pipe it back to dd to write it as a binary file.
-----------------------------------------------------------------
With my data recovery programs here and Linux commands this 
becomes a very powerful package for data recovery of any
file that can possibly exist anywhere in space-time without connecting to another computer.

You can use the man command to find out what each of this commands do.

Sometimes you can type the command -h to get more help.

You can put commands to a text file with the command
Man alert > alert.txt and build your own little book of commands
and read it.

---------------------------------------------------------
Use | to pipe one command to another use > to store the output into something.

Well I would like to speak more but I go to go. I am updating my lottery program and trying to get a list of commands in Linux that people can use to computer time travel on the Linux command line.

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

02/20/2017 05:26 AM

To computer time travel in Linux you need to be able to do these things.

Use /dev/random
Split files
Join files
Convert numbers to other bases and back
Add two files together
Subtracted two files
Look at file formats
Search a text file 
Convert binary files to higher bases and put that in a text file
Convert text files containing numbers in a base to binary
Work with checksums
Plot and graph regression lines
Use command line math functions
Write bash scripts
Use Linux commands
Pipe commands
Store information in variables or files

This just gives you the general idea there is a lot more.

I mean my software in c++ is good but with Linux computer time travel becomes very very powerful. Also bash scripts and Linux commands are easier to use than C++. 

This is why hacker use scripting languages rather than programming languages. Scripting languages and the command line is way easier than programming. But now with my methods computer time travel every computer file in space-time can be at anyone's finger tips. Whether they program or script.

I still like my C++ programs because people can computer time travel without knowing how to script or program but knowing some Linux commands are required.
---------------------------------------------------------------------------------------------------------------------------
02/20/2017 04:38 PM

I am not programming today but I am planning the direction of time travel project. How I am going to use Linux in my computer time travel projects in the future is of course it will start with C++ my code of choice. The user can run my program from the command line. The program will then write a bash script the C++ will execute or leave it to the user to run it. 

What I want to do is make time travel project into a Linux package hosted on the the internet and people can use apt-get install timetravelproject and install it on their system and reconstruct computer files from all across space-time.

Of course I already know the C.I.A and N.S.A. position on this. They are like 'Oh hell no". My position on this is "To f****** bad. Deal with it."

To my calculations there are currently 240 Billion technologyally Advanced civilizations each having over one trillion computer files. So that means there are 240 billion x 1 trillion computer files from technologically advanced civilizations in the known universe. All at the touch of your finger from a Linux computer system. Oops, the government didn't see that coming.

Baaaaaaaaaaaaaaahahahahahahaha!!!!!!!!!!!!!!!!!!!!!!!!!

The government is like "OH SHIT!!!!!!!!!" So I have found out through the years with the hacking, stalking, and harassment.

Now no one can look at that many real computer files in their life time but a person can look at some of them. Precision computer time travel is extremely mathematical.

I tried to stream line the process in my code and make it easy for the public. Take a destination file and use the destination file to find target files by adding or subtracting differences from the destination file in a numerical base. Then check the file formats for good files.

When your done with the destination file add to it or subtract from it thus moving it up or down the regression line. Then come in with more thousands and thousands of difference files and find the targets around the destination file again by adding or subtracting the difference files from the destination file in a numerical base.

Very simple. I took the math equations right out of that puppy so the public does not have to deal with them unless they want to.

Then there is purely random computer time travel. "ITS LIKE A BOX OF CHOCOLATES. YOU NEVER KNOW WHAT YOUR GOING TO GET". To borrow a old quote.

So I will use bash when possible ran from C++ when not I will go to C++. I will have to make my code to conform to Linux standards. 

I took a old hard drive from a scrap computer so now I have what I need to start running computer time travel projects again at home. Of course this computer will not have internet. After my initial hacking and hassrassment from HTTP://timetravel.institute aka HTTP://timetravelinstitute.com ran by the USA government by Ray Hudson, Darby Phillips, and Pamela who are federal USA government agents I am starting to get my computer travel back on track. And why have the internet anyway when you can have "SPACE-TIME INTERNET". 

And their new flunky (Talking to the Conspiracy) Aaron if that is his real name will not get access to my projects. It ain't happening.

But I will continually release my code as open source. To Ray, Darby, and Pamela's horror. 

Thursday, January 26, 2017

Upgrading Time Travel Computer Code

COPYRIGHT(C) 2017 http://time-travel.institute

Copy of public version of time travel computer code at http://sourceforge.net/projects/timetravelproject/


01/26/2017 10:00 PM


I am fixing to upgrade from counter 11 to counter 12 then write my base power counter to run in memory. Then finish up fire codes project generators. Then upgrade my configure file generators and number generators in all my projects. After that I will look at bringing the Burris Numerical System into "Time Travel Project" at sourceforge.


After I finish getting the bottom half of my code upgraded I have to get the top half of my code upgraded. The bottom half of the code is the time travel vehicle itself. The top half of the code is the time travel guidance and control systems. Both half of the codes make up an entire time machine. Off to work.  Talk to everyone later.

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

01/26/2017 11:38PM


I am got a start on counter 12. Before I can finish it I have to write a program that will generate a random binary file for the destination file starting out or the user can give one. Then I have to use a tool to get a strong check-sum of a good file. Then I will program counter 12 to recreate that good files strong check-sum. This is the part of the program that maps every computer file in space-time to a number that can be re-constructed by this program.


Now this part is the guidance and control system for the program. These two things is how you build a computer software program that can time travel. The top half is the guidance and control the bottom half is the time travel vehicle itself. This part starts out using a random destination file. But every time it gets closer to its target strong check-sum it will recycle its old target file to its destination file. This is called the pendulum algorithm. It will do this until it finally hits its target strong check-sum.

Then the pendulum comes into balance with its fulcrum. It works in physics and it works in cracking check-sums too and decoding them to computer files.

It can be shut down by deleting its lock file. When that happens it writes its destination file and its closest target file to the hard drive. to begin anew the next day. The destination and the target is the control counter and the experimental counter. Then a new low is reached the experimental becomes the control and the control becomes the experimental until the pendulum is in balance with its fulcrum.


When that happens the destination check-sum will equal the target check-sum and the file WILL BE RE-CONSTRUCTED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

THIS GIVES PRECISION CONTROL FOR COMPUTER TIME TRAVEL. IT GIVES PRECISION GUIDANCE AND CONTROL FOR COMPUTER TIME TRAVEL.

In the beginning I spent most of my time writing time travel code for myself and computer time traveling and pissing off the "Conspiracy Against Time Travel" by not leaving the internet as they had ordered me to do.


Now, in my fight against the "Conspiracy Against Time Travel" I now spend my days writing time travel computer code for the public while doing very little time travel myself. This is the best way I can fight them. To show them who is the boss. I am the boss of myself. They are not my bosses and never will be.

----------------------------------------------------------------------------------------------------------------
01/27/2017 07:57AM

This morning I was looking at some time travel media and I realized that as time goes on it becomes irrelevant to the present except when the past was ahead of the present. Except for a very few small pockets of science and special people like myself.
---------------------------------------------------------------------------------------------------------------------------------
01/28/2017 12:08 AM

I was going to write a project generator for fire codes but I realized I already had a project generator. So, instead of feeding random binary to fire codes to generate project files it is far faster to use the binary generator to generate time travel media. Then after the robot gets done checking the files feed the good files to fire codes. This would be good for encrypting time travel media since fire codes has to have a password to decode a config file. So, I am done with fire codes. I put the binary generator project with fire codes. I guess I should write a file wiper and get Predator up and running in c++ so people can clean the computers of time travel media files.


I got a lot of experimenting and updating to do to make this production level computer time travel.


I got my buffer working in the binary generator. I was generating 500 mega byte files in a couple of seconds. SO I CAN FLASH LIGHTING GENERATE TIME TRAVEL MEDIA FILES NOW. Now I should turn my attentions to the guidance and control systems. I think I have enough time travel media vehicles. I still got to rewrite my base power counter but it works right now.


My binary generators is where the real computer time travel will probably occur. I have to treat the binary files as numbers in a numerical base and define ranges in those numbers where I think time travel media files will be. So I could work on software now that looks at files as numbers. It can be used for all the projects including fire codes. 


So guidance and control is where I will go next.

------------------------------------------------------------------------------
01/28/2017 01:41 AM

Ok, I just went over the guidance and control aspect of this really well. To get computer time travel media files Weighted Strong Check-sums are the coordinates to use on the space-time informational universe. I need to try to find my old version of fire codes because it had software that can generate files by their strong check-sums. So, If I don't find that I will have to rewrite it.


Counter 12 is the best way to go to a specific strong check-sum and so is my binary generators and my tools.


The file generators must generate files within the specific high low range of two weighted strong check-sums. Any files within that specific range are possible time travel media files.


So, my programs already do this each one does it in its own way. I may do some more playing around and see what I can do.


So what I should do now is start using my own software to computer time travel and tweak it as I go along. The world is welcome to use it and tweak it to their own needs as well. So that is where I will go next. I'm off to computer time travel.

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

01/28/2017 06:32AM

I time hacked my butt off this morning and found a bug and wrote a counter. I'm going to have two types of number generators. One is purely random and the other will generate files and check-sums with in ranges. And I had a little trouble with my random number files. But it is all getting worked out.
----------------------------------------------------------------------------------------------------------------
01/28/2017 05:08 PM

Well I'm setting here this afternoon working on updating my file and check-sums generators. I realize two things. If random in ranges or not the numbers must be purely random. Second purely the files must come to numbers in a numerical base that are real files and for that I must add to them to take them up in value or subtract to take them down in value. 

So for my generators that work in ranges I will add, subtract, and compare to generate check-sums and files for time travel computer media. I will take a number in a numerical base and run it up till it surpasses it's high value then reverse it till it passes it's low value scanning a range for time travel computer media. It will be called scanner.cpp

The other file generator will be a random time travel media cracker. It too will work in a programmed range in a number in a numerical base using random numbers within a defined range. The user can make that range as tight or as loose as possible. 

With both methods it must be possible for the user to pick a target within a range and have the file or check-sum generates to hit that target. 

The algorithm I am going to use to hit my targets is simple. In mathematics with 3 variables if any two variables are known the third can be calculated. So I have a high variable and low variable. Now all I need is + or - the difference. And my check-sum or file generators will use the difference mathematically find their target.

Now, as I did with my fire codes and base power check-sums I have to prove they work. So the test will be taking a known file and proving my file generater can find it and post that video on you tube. 

So these file and check-sum generators are given a high value and low value then will be spoon fed differences to find their target values.

Now since I have mapped all computer media files in space-time as numbers my that my software can construct my only job left is to define the guidance and control system. The plan I outlined above will allow me to do that.

And again I want to again ask the world to take my computer time travel and make it their own and use it for free. This is open source and my gift to the world to fuck the conspiracy against time travel up the ass hole with a very large dick.

Take this computer time travel world. Take it. Use it for what ever you want. It's yours for free. Use it however you want.

Next step then is finding unknown time travel media files then getting that video posted on you tube.
----------------------------------------------------------------------------------------------------------------
01/28/2017 08:30PM

On my guidance and control systems for time travel project.

On the file and check-dum generators it will be just two high low numbers in a numerical base. They will be fed a directory full of differences and the results will be the target files and check-sums. Those differences between the numbers can be calculated how ever the user wants. I of course will  have one or more programs to calculate those differences.

The difference files will be both text and binary.

These programs will re place the check-sum and file generators in time travel project.

I already have a free space wiping program. My encryption program will be my file generator where the user generates a difference file with a file size and password and the user can take a known file and roll it to an encrypted file with the add 2 files tool or subtract 2 files tool. And do the reverse to unencrypt it. So, with the file generator and the add or subtract tool in time travel project a computer file can be encrypted.
--------------------------------------------------------------------------------
01/28/2017 10:49 PM

I am sitting here drinking coffee. I got a fire going in the fire place. I am fixing to sit down and start coding the file generator for time travel project. 

I have to do one with binary files for the file generator and one with text files for my base power check-sum. The counter project already goes to its target though I need to get some more bugs out of it.

This will not take long. In fact I all ready have the add and subtract two file program written. But, I am going to make it a little better than that.  The program takes two files. A high and low file. 

Then it gets a strong check-sum for both files. The strong check-sums is how I tell if a file is bigger or smaller as a number in a numerical base than another computer file. It is how I compare two files as numbers in a numerical base. 

The stronger a weighted sum is the more accurate it is. I like weighted sums because I am make them as weak or strong as a check-sum as I want. I control the strength of that check-sum.

Then it excepts a file list of difference files generated by the file generator. It will go through and get a strong check-sum of the difference files and as long as they are equal too or between the strong check-sums of the high and low file then the program will use the difference file and add or subtract it and generate a target file. That is it. Now with that any time travel computer media between the two files can be found. And I will prove it with a You Tube video like I did when my base power check-sum counter and fire codes and my other counters as well.

Once I have that guidance and control system proven for finding time travel computer media and I have already proved my counters for mapping all files in space-time to a number and coding and decoding them then the computer time travel machine on sourceforce will be upgraded. And my revenge against the "Conspiracy Against Travel" will be upgraded.

On the file generater for the base power check-sum the same thing will happen except with text files. It will be no different than the binary files. A high and low base power check-sum is generated. Then  the program is given a list of difference check-sums which are added or subtracted from the high low check-sums to hit the target check-sums in between. Then the targets are decoded as computer files.

On my base power check-sum the next upgrade will be expanding my buffer size reading the binary program. The base power counter uses two numerical bases. One for reading binary files and one for converting the base power check-sum to a number in a numerical base. So, I am fixing to lite a fire under its ass. That 16 bytes per minute will go way up. That is where I am for tonight.

After I get my guidance and control system finished I am going to write a program that can take a file off the file generator and manually take it up or down in value. The user can look at the strong check-sum and manually take this file up or down and manually control how fast that is being done.

Then I will start putting example spreadsheets in the project where people can map out time-lines and ranges where computer time travel media exist. You see, I actually plan to take this project and make it a full blown time travel machine and a full blown time travel project. 

All this shit I use to do with my proprietary time travel computer code before the government started coming into my home by way of my computer network, cameras, and phone. So, I am writing this time travel computer code for the public to use too since the government tried to steal it from me without paying me for it. 

In fact they owe me money for what that did but I doubt I will ever see a dime from them. Oh I'm sure Ray Hudson will probably mail me a dime in the mail to piss me off since I said it. But they did send me a gun re-loader from Israel so I guess I can't bitch too much. But still those guys are so dishonest and underhanded. 

The public is getting a computer time travel machine out of it anyway. So, someone got something out of it.

I got time travel project "ALL FIGURED OUT". This is no longer a theory and a good story on my part. Now it is in actual practice. And anyone one can use it and is welcome to improve upon it because it is open source.

TAKE THAT RAY HUDSON, DARBY PHILLIPS, AND PAMELA. 

BAAAAAAAAAAAAAHAHAHAHAHAHAHAHAH!!!!!!!!!!!!!!

BAAAAAAAAAAAAAAAHAHAHAHAHAHAHAH!!!!!!!!!!!!!!

BAAAAAAAAAAAAAAAAAHAHAHAHAHAHAHA!!!!!!!!!!
----------------------------------------------------------------------------------
01/29/2017 02:31 AM

I have the time scanner compiled for time travel project in the binary generator. Now, knowing the high range and the low range and using the file generator to generate difference files the scanner will run and construct the target files in between to construct time travel computer media files. I still have to run it and play with it but it is a standard issued time travel computer media scanner for time travel project. I need to spend some time upgrading my base power counter and its guidance system too. 

So without further ado and because I just know Ray Hudson is dying for me to post my time travel computer media code HERE IS THE "TIME SCANNER!".

// Begin time scanner code //////////////////////////////////////////////////////////
// COPYRIGHT(C) 2017 http://time-travel.institute
// This program takes two files. A high file and low file.
// Then it reads a file list of files it will subtract from the high or add to the low. 
// The user tells whether or add or subtract.
// Make a file list first like this ls > list.txt
// Then edit the list for any unecessary files.
// Run the program like this // ./ProgramName Buffersize HighFileName LowFileName FileList addsubtract extension
// from the command line.
// It will output target files.
// This works on the principle that if you know any two variables you can calculate the third
// So we we know our high range and our low range and the difference we can calculate your time travel media target file.
// You will have to use a random binary file generator to make the difference files. There is one at http://sourceforge.net/projects/timetravelproject/
// ============================================================================================
// Declare includes
#include cstdlib
#include iostream
#include stdlib.h
#include fstream
#include sstream
#include string
#include cmath
#include ctime
#include cstdio
#include iostream
#include "timecheckhacking.h"
// timecheckhacking.h available at http://sourceforge.net/projects/timetravelproject/
// ============================================================================================
// Declare namespace
using namespace std;
// ============================================================================================     
// declare subs
// ============================================================================================
int add(long long count3, int buffersize, string destinationfile, string differencefile, string extension)
{
         
        long long filesize2;
        long long filesize3;
        long long filesize4;
        long long count2;
        long long carry;
        int byte;
        int byte1;
        int byte2;
        int byte3;
        long long numberbase = (buffersize * 255) + 1;
        string pause;
        string whatdo;
        string file1;
        int dummyfile;

        // get filesie 2
        filesize2 = filesize(differencefile);


        // get filesize 3
        filesize3 = filesize(destinationfile);

        // if filesize 2 > 3 then filesize 4 = filesize 2
        if (filesize2 > filesize3)
        {
             filesize4 = filesize2;
        } 
        
        // if filesize 2 < 3 then filesize 4 = filesize 3
        if (filesize2 < filesize3)
        {
             filesize4 = filesize3;
        }

        if (filesize2 == filesize3)
        {
             filesize4 = filesize2;
        } 

        // get file name  from ss
         stringstream ss;
         file1 = "";
         ss << count3;
         ss >> file1;
         file1 = file1 + extension;

         fstream myfile1(file1.c_str(), ios::out  | ios::binary);
         if (!myfile1)
         {
              myfile1.close();
              cout << "error in line 245" << " " << file1 << "\n";
              cin >> pause;
              exit(1);
         }
         myfile1.close();
         myfile1.clear();
         myfile1.flush();

         carry = 0;
         count2 = buffersize * -1;
         // start third loop
         do
         {
              // increment file variable
              count2 = count2 + buffersize;

              // set byte1 to zero
              byte1 = 0;

              // read byte1 if less than filesize
              whatdo = "read";

              if (count2 < filesize3 - 1)
              { 
                   byte1 = binaryreadwrite(whatdo, destinationfile, count2, byte, buffersize);
              }

              // // set byte2 to 0
              byte2 = 0;

              // read byte2 if less than filesize
              if (count2 < filesize2 - 1) 
              {
                   byte2 = binaryreadwrite(whatdo, differencefile, count2, byte, buffersize);
              }

              // byte3 = byte1 - byte2 - carry;
              byte3 = byte1 + byte2 + carry;

              // carry = 0;
              carry = 0;

              // if byte < 0 subtract from the base
              if (byte3  > numberbase - 1)
              {
                   byte3 = byte3 - numberbase;
                   carry = 1;
              }

              // Check for error
              if (byte3 > (numberbase - 1))
              {
                   cout << "Houston we have a problem\n";
                   cout << "byte3 greater than the base - 1\n";
                   cin >> pause;
                   exit(0);
              }

              if (byte3 < 0)
              {
                   cout << "Houston we have a problem\n";
                   cout << "byte3 less than 0\n";
                   cin >> pause;
                   exit(0);
              }



              // write random binary
              whatdo = "write";
              dummyfile = binaryreadwrite(whatdo, file1, count2, byte3, buffersize);


         // end third loop
         } while(count2 < filesize4 - 1); 
         return(0);

}
// ============================================================================================
int subtract(long long count3, int buffersize, string destinationfile, string differencefile, string extension)
{

        long long filesize2;
        long long filesize3;
        long long filesize4;
        long long count2;
        long long carry;
        int byte;
        int byte1;
        int byte2;
        int byte3;
        long long numberbase = (buffersize * 255) + 1;
        string pause;
        string whatdo;
        string file1;
        int dummyfile;


        // get filesie 2
        filesize2 = filesize(differencefile);


        // get filesize 3
        filesize3 = filesize(destinationfile);

        // if filesize 2 > 3 then filesize 4 = filesize 2
        if (filesize2 > filesize3)
        {
             filesize4 = filesize2;
        } 
        
        // if filesize 2 < 3 then filesize 4 = filesize 3
        if (filesize2 < filesize3)
        {
             filesize4 = filesize3;
        }

        if (filesize2 == filesize3)
        {
             filesize4 = filesize2;
        } 

         // get file name  from ss
         stringstream ss;
         file1 = "";
         ss << count3;
         ss >> file1;
         file1 = file1 + extension;

         fstream myfile1(file1.c_str(), ios::out  | ios::binary);
         if (!myfile1)
         {
              myfile1.close();
              cout << "error in line 245" << " " << file1 << "\n";
              cin >> pause;
              exit(1);
         }
         myfile1.close();
         myfile1.clear();
         myfile1.flush();

         carry = 0;
         count2 = buffersize * -1;
         // start third loop
         do
         {
              // increment file variable
              count2 = count2 + buffersize;

              // set byte1 to zero
              byte1 = 0;

              // read byte1 if less than filesize
              whatdo = "read";

              if (count2 < filesize3 - 1)
              { 
                   byte1 = binaryreadwrite(whatdo, destinationfile, count2, byte, buffersize);
              }

              // // set byte2 to 0
              byte2 = 0;

              // read byte2 if less than filesize
              if (count2 < filesize2 - 1) 
              {
                   byte2 = binaryreadwrite(whatdo, differencefile, count2, byte, buffersize);
              }

              // byte3 = byte1 - byte2 - carry;
              byte3 = byte1 - byte2 - carry;

              // carry = 0;
              carry = 0;

              // if byte < 0 subtract from the base
              if (byte3  < 0)
              {
                   byte3 = byte3 + numberbase;
                   carry = 1;
              }

              // Check for error
              if (byte3 > (numberbase - 1))
              {
                   cout << "Houston we have a problem\n";
                   cout << "byte3 greater than the base - 1\n";
                   cin >> pause;
                   exit(0);
              }

              // Check for error
              if (byte3 < 0)
              {
                   cout << "Houston we have a problem\n";
                   cout << "byte3 less then 0\n";
                   cin >> pause;
                   exit(0);
              }


              // write random binary
              whatdo = "write";
              dummyfile = binaryreadwrite(whatdo, file1, count2, byte3, buffersize);


         // end third loop
         } while(count2 < filesize4 - 1); 
         return(0);
}
// ============================================================================================
// declare main
int main (int argc, char *argv[])
{
    // Declare variables
    int buffersize;
    string highfile;
    string lowfile;
    string addsubtract;
    string destinationfile;
    string differencefile;
    string filelist;
    string extension;
    int dummyfile;
    long long count3;

    // Take command line arguments
    // ./ProgramName Buffersize HighFileName LowFileName FileList addsubtract extension
    buffersize = atoi( argv[1]); // How many bytes we are reading at a time.
    highfile = argv[1]; // High file as a number in a numerical base.
    lowfile = argv[2]; // Low file as a number in a numerical base.
    filelist = argv[3]; // filelist containing the names of the difference files.
    addsubtract = argv[4]; // Are we adding the differences or subtracting them.
    extension = argv[5]; // file extension to give to targets.

    // open file list
    fstream c1myfile1(filelist.c_str(), ios::in);
    if (!c1myfile1)
    {
         cout << "There is no file list." << "\n";
         c1myfile1.close();
         c1myfile1.clear();
         c1myfile1.flush();
         exit(0);           
    }

    // if addsubtract == add
    if (addsubtract == "add")
    {
         // destination = Lowfile
         destinationfile = lowfile;
    }

    // if addsubtract = subtract
    if (addsubtract == "subtract")
    {
         // destination file = high file
         destinationfile = highfile;
    }

    // set count3 to 0
    count3 = 0;
    // Start do loop
    do
    {
         // increment count3
         count3++; // This is the file name

         // read file list
         c1myfile1 >> differencefile;

         // if addsubtract = subtract call subtract 
         if (addsubtract == "subtract")
         {
              dummyfile = subtract(count3, buffersize, destinationfile, differencefile, extension);
         }
  
         // if addsubtrct = add call add
         if (addsubtract == "add")
         {
              dummyfile = add(count3, buffersize, destinationfile, differencefile, extension);
         }

    // repeat till end of file list
    } while(!c1myfile1.eof());

    // print to user "ALL TARGETS CONSTRUCTED!!!!!!"
    cout << "ALL TARGETS CONSTRUCTED!!!!!!!!!!!!!!!!" << "\n";

    // Exit program
    exit(0);

}
// End time scanner code /////////////////////////////////////////////////////////////
----------------------------------------------------------------------------------

01/29/2017 04:15 AM

BASE POWER COUNTER HAS BEEN UPGRADED TO USE A LARGER BUFFER!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

YEEEEEEEEHHHHHHHHHHHHAAAAAAAAAAAAAAAAAA

It just keeps getting worse and worse for Ray Hudson, Darby Phillips, Pamela my babydoll, and that little child hacker boy/pussy of Ray's Aaron Hiniker of Bedford, PA.

BAAAAAAAAAAAAAAHAHAHAHAHAHAHAHAHAH!!!!!!!

I also fixed the program that produces a base power text file for decoding.

Anyone compiling should use basepower2.h instead of basepower.h

Man I did three updates to sourceforge tonight.

And I hope all the bugs are out. I'm done for this morning programming. My fingers feel like I have been typing for hours and hours. Wait, I have been typing for hours and hours. So, I am going to type less now.

Tomorrow I will work on upgrading the file generators for base power counter. Talk to everyone later.

Oh by the way if anyone uses my software you need to generate a weight file to get strong sums and the file generators need a random number text file. So, if anyone has had problems with my code that is why. You can usually read the code and any compile errors and figure it out. My code is not that hard to read. If Ray Hudson can read it then any child from the age of 2 on up can read it. Ok, bye now.
---------------------------------------------------------------------------------