Translate

VideoBar

This content is not yet available over encrypted connections.

Search This Blog

Friday, January 20, 2017

A.I. FOR TIME TRAVEL PROJECT COMING ONLINE. TRUMPERICA WILL BE GREAT AGAIN!!!!!!

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

01/20/2017 10:20 PM

Well today AMERICA OFFICIALLY BECAME TRUMPERICA!!

BAAAAAAAAAAAAAAAAAAAAHAHAHAHAHAHAHA!!!!!!

I am so glad he won that election. That was the most screwed up election in Trumperica history. Everyone wanted Trump to win but the crooked press and crooked politics tried to make crooked Hillary out the candidate of choice when no one wanted her in office. 

I am hoping now that America is now Trumperica things will finally get done. I now live in Trumperica U.S.A. Yeah!!!!! Maybe the affordable health care act will NOW ACTUALLY BE AFFORDABLE!!! AND NOT IMPOSED ON PEOPLE AGAINST THEIR WILL. We can all go back to WORKING FULL TIME JOBS NOW!!!!!! WE CAN ALL HAVE ACTUAL REAL JOBS NOW!!!! COMPANIES WILL NOW ACTUALLY BE BASED IN TRUMPERICA NOW!!!!

TRUMPERICA WILL BE GREAT AGAIN!!!!!!!!!!!!!!!!

MAYBE NOW THE "CONSPIRACY AGAINST TIME TRAVEL" WILL FINALLY GET FIRED FROM THEIR JOBS!!!!!!!!!!!!!!!!!!!!

Now, moving on to business. The "Conspiracy Against Time Travel" are tweeting me malicious tweets on twitter. Apparently they have not found my FaceBook page. Those guys are slacking off. Their slackers. Hahahaha. I like making fun of them. Ok this time I mean it lets down to time travel business. 

My 10 year old daughter was complaining today because the "Conspiracy Against Time Travel" was blocking her netflix and she could not watch netflix. Really "Conspiracy Against Travel"? Really Ray Hudson, Darby Phillips, and Pamela? your going to block my internet so a 10 year old little girl can't watch netflix. Really? You see, this is why the "Conspiracy Against Time Travel" need fired from their jobs. They lost the time travel war with me now they have to pick on a 10 years old little girl. What pussies these guys are. As I use to say even Pamela could kick all their asses with one hand and one leg tied behind her back. Hell, my ten year old little girl could kick their asses with one hand and one leg tied behind her back.

Ray Hudson, Darby Phillips, and Pamela I got to tell you guys if you keep blocking my kids Netflix seriously she might come your way and actually kick you guys asses. She use to take Judo and she is damn good. 

DON'T TEST HER. I WOULD HATE TO SEE YOU GUYS GET BEAT UP BY A 10 YEAR OLD LITTLE GIRL!!! SERIOUSLY!!! DON'T BLOCK HER NETFLIX ANY MORE. FUCK WITH ME IF YOU HAVE TOO  BUT LEAVE HER THE HELL ALONG. YOU HAVE BEEN WARNED!!!!!!!!

I finished the the random number generator last night. I am going to test it out tonight then start on my A.I. I am going with 1 neuron with a data base. It has to be trained for good files and it has to be trained for bad files. The more training the better it works. It will delete the bad files and move the good files to a directory. 
----------------------------------------------------------------------------------

01/20/2017 11:19 PM

Well I got my random number generator tested. It works but it would not exit the loop making check-sums. Here is a picture of how many potential time travel media files for decoding I ended up with on my hard drive.



Well I got a good free space wiper on my hands now. Hahahahah. But I got to get it fixed and get A GOOD COMPUTER TIME TRAVEL MACHINE ON MY HANDS!!!.

I got to get that loop fixed then finish up my A.I. Be back later to let everyone know my progress.
---------------------------------------------------------------------------
01/20/2017 11:58 PM

OK CHECK-SUM GENERATOR WORKING FOR TIME TRAVEL PROJECT!!!!!!!!!!!!!!!!!!!!!!!

Here is the check-sum generator code for Ray Hudson

// Start check-sum generator code
// COPYRIGHT(C) 2017 http://time-travel.institute
// THIS IS A SEEDED RANDOM NUMBER GENERATOR TO GENERATE CHECK-SUMS FOR THE BASE POWER CHECK-SUM COUNTER.
// YOU CAN GET A SEED FILE FROM RANDOM.ORG
// ============================================================================================
 // declare includes
     #include cstdlib
     #include iostream
     #include stdlib.h
     #include fstream
     #include sstream
     #include string 
     #include cmath
     #include ctime
     #include cstdio
     #include iostream
// ============================================================================================
    // Declare namespace
    using namespace std;
// ============================================================================================  
// ---------------------------------
// code example - KEEP THIS HERE.
//    count2 = 0;
//    do
//    {
//         std::stringstream ss;
//         count2++;
//         ss << count2;
//         ss >> file1;
//         file2 = file2 + ".bin";
//         cout << file2 << "\n";
//    } while(count2 < 10);
// ---------------------------------
//    // passing command line arguments to program 
//    file1 = argv[1];
//
// passing command line arguments to program 
//    filesize1 = strtoull(argv[2],NULL,10);
//
//    // passing command line arguments to program
//    howmanyweightedsums = strtoull(argv[3],NULL,10);
//
//    // PASSWORD FOR CALCULATING WEIGHTED SUMS
//    password2 = strtoull(argv[4],NULL,10);
// -----------------------------------------------------------   
// declare main
int main (int argc, char *argv[])
{ // Begin main

    // declare variables    
    long long numericalbase = 99999999; // this is your numerical base
    long long numberbase = numericalbase - 1;
    long long howmanychecksums; // This is how many files to generate. Put that in the command line arguments
    long long howmanynumbersperseed; // This is how many numbers per random seed number
    long long seed;
    long long count1;
    long long count2;
    long long count3;
    long long check1;
    long long check2;
    string file1; // Put the name of your seed file here
    string file2; // Put the name of your output file here
    string file3; // Put name of check-sum 1 file here
    string file4; // Put name of check-sum 2 file here
    string pause;
    fstream c1myfile1; // Seed file
    fstream c1myfile2; // check1
    fstream c1myfile3; // check2
    fstream c1myfile4; //outchk
    long long num;

    time_t seconds;
    srand((unsigned int) 5654940); // This seed number can be changed to what ever you want.        
    long long a = 3;
    long long c = 2361;
    long long m = 999999;
    long long k = 0;
    long long r = 0;

//    cout << "Enter the name of your seed file" << "\n";
//    cin >> file1;

      file1 = argv[1];

    // get name of file3 this is 1.chk

      file3 = argv[2];

    // get name of file4 this is 2.chk
      file4 = argv[3];

    // how many checksums
      howmanychecksums = strtoull(argv[4],NULL,10);
    
// how many numbers per seed  
      howmanynumbersperseed= strtoull(argv[5],NULL,10);

//      howmanychecksums = 10
    // set count1 to 0 how many check-sums per seed
    count1 = 0;
    // set count2 to 0 file count for generating check sum files so this is how many check sums per seed
    count2 = 0;
    // This is the name of the check-sums written out to be decoded
    count3 = 0;
    // Start first loop for how many check-sums
    do
    {
         // increment count2
         count2++;

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

         // Start loop2 for reading the seed file
         do
         {
              // read seed file
              c1myfile1 >> seed;
              srand((unsigned int) seed);
              count1 = 0;
              // Start loop3 for how many check-sums per seed
              do
              {
                   // increment count1
                   count1++;

                   // get new check-sum file name from ss
                   std::stringstream ss;
                   count3++;
                   ss << count3;
                   ss >> file2;
                   file2 = file2 + ".outchk";

                   // open check1
                   c1myfile2.open(file3.c_str(), ios::in);
                   if (!c1myfile2)
                   {
                        cout << "There is no chk file." << "\n";
                        c1myfile2.close();
                        c1myfile2.clear();
                        c1myfile2.flush();
                        exit(0);           
                   }

                   // open check2
                   c1myfile3.open(file4.c_str(), ios::in);
                   if (!c1myfile3)
                   {
                        cout << "There is no chk file." << "\n";
                        c1myfile3.close();
                        c1myfile3.clear();
                        c1myfile3.flush();
                        exit(0);           
                   }

                   // open check-sum file for ss
                   c1myfile4.open(file2.c_str(), ios::out);
                   if (!c1myfile4)
                   {
                        cout << "There is no outchk file." << "\n";
                        c1myfile4.close();
                        c1myfile4.clear();
                        c1myfile4.flush();
                        exit(0);           
                   }

                   // Start loop4 for generating check-sums using rand
                   do
                   {  
                        // generate rand
                        time(&seconds);
                        k = (rand() % numberbase); // We can randomize timer here if we want. Thats up to the user.
                        k = k + seconds;
                        num = (a * k + c) % numberbase;

                        // read check 1
                        c1myfile2 >> check1;

                        // read check 2
                        c1myfile3 >> check2;

                        // if rand > check1 and rand < check 2 write it // Just as long as it is between num1 and num2
                        if (num >= check1)
                        {
                             if (num <= check2)
                             {
                                  c1myfile4 << num << "\n"; 
                             } 
                        }

                        // if rand > check2 and rand < check 1 write it // Just as long as it is between num1 and num2
                        if (num >= check2)
                        {
                             if (num <= check1)
                             {
                                  c1myfile4 << num << "\n"; 
                             } 
                        }

                   // End loop 4 for generating checksums close at eof
                   } while(!c1myfile2.eof()); // Make sure both check sums files THE SAME SIZE!!!!!!!!!!!!!!!!!!!!!!

                   // close check 1
                   c1myfile2.close();
                   c1myfile2.clear();
                   c1myfile2.flush();

                   // close check 2
                   c1myfile3.close();
                   c1myfile3.clear();
                   c1myfile3.flush();

                   // close check-sum file for ss
                   c1myfile4.close();
                   c1myfile4.clear();
                   c1myfile4.flush();
                   // Extra get out statement because my others don't work.
                   if (count1 == howmanychecksums)
                   {
                        exit(0);
                   } 
              // end loop 3 for how many check-sums per seed
              } while(count1 < howmanychecksums);
         // End loop 2 for reading seed file close at end of file
         } while(!c1myfile1.eof());
         // IF NUMBER OF CHECK-SUMS NOT REACHED INFORM USER TO GENERATE NEW SEED FILE.
         if (count2 < howmanychecksums)
         {  
              // PAUSE PROGRAM WHILE WAITING FOR NEW SEED FILE
              cout << "PLEASE REPLACE SEED FILE!!!!!!!!!!!!" << "\n";
              cin >> pause;
         }
    // end loop one for how many check-sums
    } while(count2 < howmanychecksums);
    // exit prograom
    exit(0);

} // End main
// End check-sum generator code

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

01/21/2017 2:45 AM Chicago time

OH MY FUCKING GOD I GOT A ROBOT NOW THAT CAN BE TRAINED TO KEEP THE GOOD FILES AND DELETE THE BAD FILES!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

BAAAAAAAAAAAHAHAHAHAHAHAHAHAHAHAH!!!!!!!!

IT JUST KEEPS GETTING WORSE AND WORSE FOR RAY HUDSON, DARBY PHILLIPS, AND PAMELA.

IM OFF TO WRITE 2 PROGRAMS. ONE TO CODE AN ENTIRE LIST TO BASE POWER CHECK-SUMS AND ONE DECODE AN ENTIRE LIST OF BASE POWER CHECK-SUMS TO

TIME TRAVEL COMPUTER BINARY MEDIA FILES!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

ITS COMING!!!!!! COMPUTER TIME TRAVEL IS COMING!!!!! OH GOD I AM SO GOING TO FUCKING COMPUTER TRAVEL!!!!!!!!!!!!

AND THE WORLD CAN COMPUTER TIME TRAVEL TOO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Here is the robot code
// start robot code
// This program gets strong check-sums of files and writes them to a list  with a 0 or 1 for output for training
// When ran it test other files and uses the neigherst neighbor method to find a good file or a bad file.
// This program just have a weights file
// COPYRIGHT(C) 2016 http://time-travel.institute
#include cstdlib
#include iostream
#include stdlib.h
#include fstream
#include sstream
#include string
#include cmath
#include ctime
#include cstdio
#include iostream

using namespace std;
// declare subs
// ======================================================================================================================
// open list of files. Get strong check sum for files and write them to strongchecksum.txt with file names
    int getstrongsumsfilelist2(long long howmanyweightedsums, int buffersize)
    {
         // declare variables
         fstream c1myfile1("list.txt", ios::in);
         fstream c1myfile2("strongsums.txt", ios::out);
         // open file2 for weights
         fstream c1myfile3("weights.txt", ios::in);
         string file1; 
         fstream myfile1;
         long double x1;
         string x2;
         int byte1 = 0;
         long double schecksum = 0;
         long long begin1;
         long long count1;
         long long count2;
         unsigned char buffer(buffersize);
         long long size1;
         long long size2;
         long long filesize1;
         long long end1 = 0;
         string pause;
//         stringstream ss;
         
         // open main loop
         do
         {
              // read list
              c1myfile1 >> file1;
              if (c1myfile1.eof())
              {
                   break;
              }   
// get strong check sum

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

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

              // Two loops that get the strong check-sum
              count1 = 0;
              schecksum = 0;
              // start loop 1
              do
              {
                   // read file1
                   byte1 = 0;
                   // read file1
                   myfile1.seekg(count1);
                   myfile1.read( reinterpret_cast( &buffer ),buffersize);
                   begin1 = myfile1.tellg();
                   // byte1 = read from file 1
                   byte1 = (int)buffer;

                   count2 = 0;
                   // start loop 2
                   do
                   {
                        // count2++;
                        count2++;
                        // read weight file. 
                        c1myfile3.precision(36);
                        c1myfile3 >> x1;
                        // schecksum = schecksum + (byte1 * x1);
                        schecksum = schecksum + (byte1 * x1);
                   // end loop 2 for how many weighted sums
                   } while(count2 < howmanyweightedsums);
                   // count1 = count1 + buffersize;
                   count1 = count1 + buffersize;
              // end loop 1 for count1 < filesize1 - 1
              } while (count1 <  filesize1 - 1);
              // close file1 for program
              myfile1.close();
              myfile1.clear();
              myfile1.flush();     
              // write weak check-sum to file
              c1myfile2.precision(36);
              c1myfile2 << file1 << " " << schecksum << "\n";
        // repeat main loop to end of file
         } while(!c1myfile1.eof());
        // close list.txt
         c1myfile1.close();
         c1myfile1.clear();
         c1myfile1.flush();
        // close strongsums.txt
         c1myfile2.close();
         c1myfile2.clear();
         c1myfile2.flush();
        // close file2 for weights
         c1myfile3.close();
         c1myfile3.clear();
         c1myfile3.flush();
    }
// ======================================================================================================================
// ===========================================================================================
    int getstrongsumsfilelist1(long long howmanyweightedsums, int buffersize, int test)
    {
         // declare variables
         fstream c1myfile1("list.txt", ios::in);
         fstream c1myfile2("database.txt", ios::out | ios::app);
         // open file2 for weights
         fstream c1myfile3("weights.txt", ios::in);
         string file1; 
         fstream myfile1;
         long double x1;
         string x2;
         int byte1 = 0;
         long double schecksum = 0;
         long long begin1;
         long long count1;
         long long count2;
         unsigned char buffer(buffersize);
         long long size1;
         long long size2;
         long long filesize1;
         long long end1 = 0;
         string pause;
//         stringstream ss;
         
         // open main loop
         do
         {
              // read list
              c1myfile1 >> file1;
              if (c1myfile1.eof())
              {
                   break;
              }   
// get strong check sum

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

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

              // Two loops that get the strong check-sum
              count1 = 0;
              schecksum = 0;
              // start loop 1
              do
              {
                   // read file1
                   byte1 = 0;
                   // read file1
                   myfile1.seekg(count1);
                   myfile1.read( reinterpret_cast( &buffer ),buffersize);
                   begin1 = myfile1.tellg();
                   // byte1 = read from file 1
                   byte1 = (int)buffer;

                   count2 = 0;
                   // start loop 2
                   do
                   {
                        // count2++;
                        count2++;
                        // read weight file. 
                        c1myfile3.precision(36);
                        c1myfile3 >> x1;
                        // schecksum = schecksum + (byte1 * x1);
                        schecksum = schecksum + (byte1 * x1);
                   // end loop 2 for how many weighted sums
                   } while(count2 < howmanyweightedsums);
                   // count1 = count1 + buffersize;
                   count1 = count1 + buffersize;
              // end loop 1 for count1 < filesize1 - 1
              } while (count1 <  filesize1 - 1);
              // close file1 for program
              myfile1.close();
              myfile1.clear();
              myfile1.flush();     
              // write weak check-sum to file
              c1myfile2.precision(36);
              c1myfile2 << file1 << " " << schecksum << " " << test << "\n";
        // repeat main loop to end of file
         } while(!c1myfile1.eof());
        // close list.txt
         c1myfile1.close();
         c1myfile1.clear();
         c1myfile1.flush();
        // close strongsums.txt
         c1myfile2.close();
         c1myfile2.clear();
         c1myfile2.flush();
        // close file2 for weights
         c1myfile3.close();
         c1myfile3.clear();
         c1myfile3.flush();
    }
// ======================================================================================================================

//============================================================================================

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

     char choice;
     int test;
     int test2;
     string pause;
     string file1;
     int dummyfile;
     int buffersize = 1;
     long long howmanyweightedsums;
     long double num1;
     long double num2;
     long double answer = 999999999999999999;
     cout << "Select your choice." << "\n";
     string file;
     string file3;

     cout << "\n";

     cout << "1. Train a new data base." << "\n";

     cout << "\n";

     cout << "2. Find good files and delete bad ones." << "\n";

     cout << "\n";

     cin >> choice;

    if (choice=='1')
    {
         cout << "Make a list.txt for the files" << "\n";
         cin >> pause;
         cout << "Enter 1 for good files enter 0 for bad files" << "\n";
         cin >> test;
         cout << "How many weighted sums are we using for the strong check-sums" << "\n";
         cin >> howmanyweightedsums;
         dummyfile = getstrongsumsfilelist1(howmanyweightedsums, buffersize, test);
         cout << "Data base generated. Put this file up and keep it you will need it." << "\n";
         exit(0);
    }

    if (choice == '2')
    {
         cout << "Make a list.txt for the time travel files to check" << "\n";
         cin >> pause;
         cout << "How many weighted sums are we using for the strong check-sums" << "\n";
         cin >> howmanyweightedsums;
         dummyfile = getstrongsumsfilelist2(howmanyweightedsums, buffersize);
         cout << "List of files to check generated" << "\n";
         cout << "Make sure your data base is is in the same directory" << "\n";
         cout << "Checking files. Deleting bad files. Keeping good files" << "\n";
         fstream c1myfile1;

         // open strongsums.txt
         fstream c1myfile2("strongsums.txt", ios::in);
         if (!c1myfile2)
         {
              cout << "Unable to open file line 302 \n";
              system("pause");
              exit(1); // terminate with error
         }

         // start first loop
         do
         {
              num1 = 0;
              // read strongsums.txt
              if (!c1myfile2.eof())
              {
                   c1myfile2 >> file3 >> num1;
              }

              // open data base
              c1myfile1.open("database.txt", ios::in);
              if (!c1myfile1)
              {
                   cout << "Unable to open file line 302 \n";
                   cin >> pause;
                   exit(1); // terminate with error
              }

              // read the data base and find closest match
              answer = 999999999999999999;
              // start second loop
              do
              {
                   num2 = 999999999999999999;
                   if (!c1myfile1.eof())
                   {
                        // find closest match
                        c1myfile1 >> file1 >> num2 >> test;
                   }
                   if (abs(num1 - num2) <= answer)
                   {
                        answer = abs(num1 - num2);
                        test2 = test;
                        file3 = file1;
                   }
              // end second loop
              } while(!c1myfile1.eof());
              // close data base
             c1myfile1.close();
             c1myfile1.clear();
             c1myfile1.flush();

              // if closest match 0 delete file
              if (test2 == 0)
              {
                   if( remove( file3.c_str() ) != 0 )
                   perror( "Error deleting file" );
                   else
                   puts( "File successfully deleted" );

              }
         // repeat loop till end of file

         } while(!c1myfile2.eof());
         system("rm strongsums.txt");
         c1myfile2.close();
         c1myfile2.clear();
         c1myfile2.flush();
         // Tell user files checked. Bad files deleted
         cout << "Files checked. Bad files were deleted" << "\n";
         // end program
         exit(0);     

    }



}

// end robot code

---------------------------------------------------------------------------------
01/21/2017 03:52 AM Chicago time

I have a program that will take the check-sums generated from the base power check-sum generator and decode them to time travel binary computer files. Here is the code. THIS IS FOR YOU RAY HUDSON AND DARBY PHILLIPS AND PAMELA!!!!!!!!

Well I am done for today. I need to test and debug the program below but it compiles. I doubt there is little wrong with it.

Time Travel Project at http://sourceforge.net has been updated. 

// Begin check-sum list decoder
// COPYRIGHT(C) 2017 http://time-travel.institute
// This is the cpp file use the base power counter header file.
// Base Power Counter 
// Load configure file
// Create configure file
// Encodes base power check-sum
// Decodes base power check-sum
// ============================================================================================
 // declare includes
    #include cstdlib
    #include iostream
    #include stdlib.h
    #include fstream
    #include sstream
    #include string 
    #include cmath
    #include ctime
    #include cstdio
    #include iostream
    #include "basepower.h" 
// basepower.h tt http://sourceforge.net/projects/timetravelproject/

// ============================================================================================
    // Declare namespace
    using namespace std;
// ============================================================================================     
// declare subs
// ============================================================================================
// declare main
    int main (int argc, char *argv[])
    {

         // declare variables
         string file2;
         long long numberbase = 99999999;
         int dummyfile;
         int buffersize = 1;
         long long filesize1 = 0;
         string pause;
         long long end1;
         long long begin1;
         // declare variables
         fstream c1myfile1;
         // ASK USER TO CREATE LIST OF CHECK-SUMS TO DECODE
         cout << "Create a list.txt file of check-sums to decode";
         cin >> pause;
         // ASK USER TO SUPPLY A POWER.TXT FILE
         cout << "Make sure you have a power.txt file named powerbak.txt";
         cin >> pause;
         // ASK USER WHAT FILE SIZE ARE WE DECODING TODAY
         cout << "What file size are we decoding today?";
         cin >> filesize1;
         // OPEN LIST
         c1myfile1.open("list.txt", ios::in);
         if (!c1myfile1)
         {
              cout << "There is no file list." << "\n";
              c1myfile1.close();
              c1myfile1.clear();
              c1myfile1.flush();
              exit(0);           
         }
         // START DO LOOP
         do
         {
              // READ LIST
              file2="";
              if (!c1myfile1.eof());
              {
                   c1myfile1 >> file2;
                   rename(file2.c_str() , "pbchecksum.txt");
                   file2 = file2 + "bin";
              }
              // copy power back up file to power.txt
              system("cp powerbak.txt power.txt");
              // PAST FILE TO BE DECODED ALONG WITH NAME TO DECODED TO LIST
             cout << "Beginning Decode" << "\n";
             dummyfile = decodepbchecksum(file2, filesize1, numberbase, buffersize);
             cout << "FILE RECONSTRUCTED FROM ITS BASE POWER CHECK-SUM IN BASE 99999999!!!!" << "\n";
             system("rm pbchecksum.txt");
             system("rm power.txt");
        // REPEAT LOOP TILL END OF FILE
        } while(!c1myfile1.eof());

         

    }
// End check-sum list decoder