What the "program" does :

Main starts by calling the Load function which loads the holding array 
with a set of values stored in a file. The holding array element consists on
a value representing account balances indexed on account identifiers. The 
array can be accessed by the account id to find the balance for a particular 
account's balance or by a numeric index.

The memory needed to read and buffer any files read is outside of our virtual 
space and has no effect. 

However, the Allocate function, which is also outside the application's virual 
memory space, will cause a physical frame to be used in order to initialize 
the memory requested.

The array is then loaded from the file.

Once an array is loaded, execution returns to Main with a count of the number
of records read in. At this point, Main needs to be reloaded into a physical 
frame of memory if it has been swapped out.

Main calls Load a second time to load the "activity" array representing a set 
of changes to be applied to various accounts. Once all of activity records 
have been stored in the array, Load returns to Main. 

Main calls Allocate to get memory to record changes in the holding records.
Although Allocate is outside the virtual memory space, the memory it is 
allocating for the "net" array will exist in a physical frame as Allocate
executes.

The program then calls the Update function which starts by duplicating the
contents of the "holding" array in the "net" array. Update, "holding", and
"net" must all be in frames.

It then examines the "activity" array and uses its entries to update the
"holding" array. It is possible that "activity" has more than one acvitiy to
apply to a particular account in the "holding" array. When done, the values
store in "holding" may be more, less, or the same as the original values now
stored in "net".

Finally, Update will match the account ids in holding and net calculate 
the difference, storing it back in the appropriate element of "net.

Note that Update, "net", and "holding" will all be in physical frames at
this time.

Execution now returns to Main.

Main calls Tax and passes it the "net" array and the tax rate. Tax then
calculates the cummulative difference of all accounts and returns a final
value.

Main then calls Print to print the values stored in "holding"

And finally, Main calls Print a second time to print the changes in each
of the accounts.

Upon completion, Print returns to Main