                 DOCUMENTATION FOR "STAR"

  STAR is a surprisingly sophisticated piece of financial software, allowing
  the management and accrual of personal expenses. It is written to be used
  by those who wish to take complete control of their personal expenses. In
  order to use STAR, you must be able to manage COMMAND/CMD files and use a
  text editor. STAR is run in a COMMAND/CMD window or full-screen.

  LEGAL DISCLAIMER:
  UNDER NO CIRCUMSTANCES IS THERE ANY WARRANTY OF ACCURACY OR OBLIGATION
  OF ANY KIND BY THE AUTHOR IMPLIED WITH THE USE OF THIS PROGRAM.

  STAR allows you to manage future expenses through what are called
  "star accounts". These are user-named accounts (you choose how many and
  their names) that hold or accrue various subtotals of your bank account.
  These star accounts are like separate bank accounts, except the bank has no
  knowledge of their existence. They can have either positive or negative
  amounts in them. For instance, you may have a star account for your
  credit card, which is used to put money into until the actual bill
  arrives. When the bill arrives, the star account is emptied to pay the bill.
  This method allows you to keep track of how much freely spendable money you
  have in your bank account, versus money that is needed for expenses that will
  come due at a later date.

  One note of caution. STAR is essentially operating in the future, which can
  cause the actual bank balance to become negative in the present, due to
  negative balances in star accounts that will only be paid off with future
  income. Thus, to safely use STAR to its fullest extent, you will need either
  a large enough line of credit with the bank or enough surplus cash in your
  account to compensate for the negative star accounts you create.

  STAR also allows you to keep track of your individual expenses through what
  are called "budget accounts". These are similiar to star accounts, but do not
  effect any balances. Each budget account has a projected spending quota, or
  budget (which may be zero or negative). As individual payments are applied
  to the associated budget account, a running total is kept and subtracted
  from the budget, allowing you to see what has been spent for that budget
  and what is remaining.

  Two sample STAR files are included (STAR.INP and STAR.OUT) which are fully
  explained below.

  This is shareware and may be freely distributed. If you find this program
  useful, send $25 to

           John David
           25 Brett Road
           Fairfield, CT 06824-1718

  Sending this payment entitles you to three email queries for help with
  questions, to the following address:

           jedavid@optonline.net

  To start, create a new directory ("\STAR") then copy everything there.
  STAR.EXE is the program, STAR.INP is a sample STAR-formatted input file
  and STAR.OUT is a sample STAR-formatted output file, the result of STAR
  having processed STAR.INP. DOSPRINT.EXE is a program to print files from DOS.
  Since the newer printers do not include a DOS driver, PRINT.BAT is
  also included, which allows printing from MSWORD. PCD.EXE is a standalone
  version of the PaycheckDeduction module that resides in STAR. PCE.EXE is
  a standalone program to calculate how many paychecks there are before a
  given expense date, enabling the intial setup of autopay. CB.EXE is a
  program that will extract and allocate the charge information from the
  Citibank Cardmember Central Web site. STARS.EXE is a search and summation
  program that allows you to gather data from multiple STAR-formatted files.
  It requires the creation of an ascii text file with the paths to the
  STAR-formatted files to search. It is useful in providing an estimate
  of yearly expenses in a given category, which then can be used to program
  STAR.AUTO.PAY for irregular billing. Remarks are delimited by spaces, tabs
  "!" characters or a leading "rem". STARS can maintain a "default" input file,
  STAR.DEF, which can be used instead of manually entering parameters. This
  file may be edited as long as the conventions are maintained. Also custom
  default input files may be used. CALC.EXE is a formula processor which allows
  many mathematical and date/time calculations. A doskey assigment to a single
  letter, such as "K", provides a handy command line calculator. PCALC.EXE
  integrates the functionality of CALC with data stored in STAR files, using
  the PCALC programming language. This language also can be accessed directly
  within STAR, as explained below. In this case, PCALC.EXE can be used as
  a tester of the PCALC instructions, without effecting any STAR files. Note
  however the results will generally not be the same as running inside STAR.
  COLORS.EXE allows for screen colors. PCA.EXE is a program that can be
  used to verify income averaging as implemented by STAR.AUTO.INC.AVE,
  described below.

  SB.EXE is a program to display the balance in a collection of STAR files
  as follows:

  SB.EXE <file1>/ttsz=<ttsz> <search1> ... <searchn> :: <file2> <search1> ....

  where <file> is the input file to search, <ttsz> is the maximum allowable
  characters displayed as a single line and "::" is a separator that restarts
  SB with a new file search. <search> may begin with "$" to specify beginning
  of line match only.

  STAR is run in console mode of WIN98/ME/2000/XP/VISTA. It will not run
  in Windows 3.x, DOS, WIN95, NT. To execute STAR, click on Start then Run,
  then type Command then hit <enter>. Then issue the commands "cd \star"
  and "dir". To simply this, you may wish to make a shortcut to
  \windows\command.com with the default directory (\STAR) pre-defined.
  It is recommended that COMMAND/CMD be run with a full-screen with the number
  of lines set to 25. The memory should be maxed out in all categories with
  the "protected mode" box checked. To make a short-cut icon to COMMAND/CMD,
  right-click on the desktop and create a shortcut to

       C:\WINDOWS\SYSTEM32\CMD.EXE /K            (WIN2000/XP/VISTA)

             or

       C:\WINDOWS\SYSTEM32\COMMAND.EXE           (WIN98/ME).

  The full command to run STAR is:

          STAR  <input_file> [<output_file>] [/sort=[[+],-][0,1,2,3,[4]]/z*/v]

  where <input_file> is a STAR-formatted input file and <output_file> is a
  STAR-formatted output file. Both files are meant to be edited with an
  ordinary text editor, such as EDIT (\windows\command\edit). An abbreviated
  command to run STAR is:

          STAR  <input_file>

  In this case, the output file will be the same as the input file,
  <input_file>. When the input file equals the output file, the input file
  is saved to <file_name>.bak.

  The briefest command to run STAR is:

          STAR  .<ext>

  In this case, the input file will be STAR.<ext> and the output file
  the same, STAR.<ext>, with STAR.BAK the saved input file. If the
  definition file STAR.TLN is in the current or root directory with
  the definitions (lines)

  STAR.DEF.NAM <name>
  STAR.DEF.EXT <extension>

  then <name> will be used in place of "STAR" and <extension> will be
  used in place of "ACT", as listed above.

  You can determine the order of the output in the archived section,
  (after the $END record), by entering the optional

                     /sort=[[+],-][0,1,2,3,[4]]

  where "+" indicates ascending (default) and "-" indicates descending.
  "1" indicates the first column (activity), "2" the value, "3" remarks
  and "4" the date. For instance,

           STAR star.act /sort=4

  is the (default) ascending sort on the date with input = output =
  "star.act", while

           STAR  star.act /sort=-4

  is the sort on the date in descending order. See below for embedding.

  You can automatically zero out all star account balances by including
  the switch "/z*" as in

          STAR star.act /z*

  For verbose output, specify the switch "/v".

  For alert only processing without new file creation, use "/a".

  To index filter previously processed lines (begining with "%"), use the
  switch "/filter=(<string>)" where <string> must match somewhere
  in the processed line in order to be accepted. If <string> is
  not somewhere on the previously processed line, that line will not
  be processed for budget values or other processing requirements.

  To date filter previously processed lines (begining with "%"), use the
  switch "/after=<yymmdd>" where <yymmdd> is the earliest date
  in the processed line in order to be accepted. If the date of the
  transaction (last 6 characters) is less than <yymmdd>, that line will not
  be processed for budget values or other processing requirements.

  STAR processes the input file of format described below to produce an
  output file. If you choose different file names for input and output
  files, the output file should replace the input file after being reviewed
  for accuracy, using the MOVE command. However, you may wish to archive
  a copy of the input file before replacing it. If you chose the same file
  name as both input and output, be careful to save either the input file
  before processing or save the .BAK file afterwards if necessary, before
  processing a second time with the same input and output names.

  STAR automatically creates a SBK.BAT file, which can be executed to restore
  the STAR file that was last processed to its previous state. Enter the
  windows command SBK to execute this command. You can customize SBK by
  using the following directive:

  =STAR.SBK.COMMAND <cmd>

  which will enter <cmd> followed by the star file name as a command in
  SBK.BAT. The default command is "dir". You may add comments by starting
  them with "!". Any argument starting with a "!!" is converted to a "!"
  and accepted as part of the command, as long as that argument occurs
  before one starting with a single "!".

  STAR-formatted files must abide by the following rules:

  The first part of a STAR file is the header section, which is a group of
  lines beginning with either "@", "*", "&", "#" or "=". A "@" represents a
  "macro command" as explained later on, a "*" represents a "star" account,
  an "&" represents a "budget" account and a "#" represents the "main" balance,
  the actual account balance, less any star accounts. The main balance should
  only occur once, while the other types of accounts can occur multiple times,
  once for each account name. "=" represents a directive, such as defining the
  cycle date, as explained below.

  Following a leading "*" is the star account name which then is followed by a
  space and a value, the current balance for that star account. A star
  account balance may be positive, zero or negative. If it is positive,
  the main balance is decreased correspondingly. If it is negative, the
  main balance is increased correspondingly. If the first character of the
  star account name is a "~", then this is a pseudo star account. Pseudo
  star accounts behave in the same manner as ordinary star accounts with
  the exception they have no effect on the balances. They can be useful
  for storing non-monetary data, such as number of shares owned.

  Following a leading "&" is the budget account name which is then followed by
  a space and up to five values. The first value is the "target" or quota
  for that account. This value is initially user-entered and the defines the
  budget and can appear multiple times. The sum of all definitions for a
  budget is the total for that budget. In the header section, the budget
  appears with its most current definition as this first value, with additional
  STAR-generated values as follows. The second value is the amount spent or
  used by that account and the third value is the amount remaining or left in
  that account. If the directive STAR.CUR.DATE is specified, the fourth value
  "&$cur" is the sum of the latest expenses. The next value is the "&etgt"
  given by the directive STAR.BUDGET.PRM. You may maintain comments after
  the budget data by entering " - " followed by the comments.

  None of the budget balances effect the star account balances or
  the main balance. In order to equalize the budget with the amount spent
  automatically, define the directive STAR.BUDGET.USED with the budget
  name. For those budget accounts that are listed as STAR.AUTO.PAY in the
  other STAR file, use STAR.BUDGET.USEA instead of STAR.BUDGET.USED.
  Budget statistics for these budgets will be listed as zero with the
  exception of the "target", which will be the total spent for that budget
  account.

  For instance, suppose there is a budget account called "expenses"
  which should have its budget always equal to what is spent for them.
  Then enter at the begining of the file:

  =STAR.BUDGET.USED expenses

  In unison with accounts that are classed as "STAR.BUDGET.USED" and
  "STAR.BUDGET.USEA" is a flag

  =STAR.CHARGE.USED <value> <budget> <account>

  which, if <value> = "1" then will cause a comment line of text immediately
  after "$END" which can be used to charge accounts in another STAR file, if
  copied appropriately to that file. If <value> = "2" then "1" applies and
  any charges that are not new will not be included either in STAR.BUDGET.USED
  [.USEA] accounts or the comment line. If <budget> is entered, this will
  capture the remaining amount after all other STAR.BUDGET.USED [.USEA] are
  applied. If <account> is entered, this will be pre-pended to the charge
  string. If you don't wish to enter <budget> but do wish to enter <account>,
  enter "." in the place of <budget>.

  If you are paying a bills for items that you would like to see combined into
  a single budget in the current file, yet listed in the STAR.CHARGE.USED
  comment line as themselves, specify the flag

  =STAR.BUDGET.DEF <combined_budget> <budget>

  For instance

  =STAR.BUDGET.DEF bills phonebill
  =STAR.BUDGET.DEF bills paperbill

  will combine both budgets "phonebill" and "paperbill" into one budget
  "bills" yet will report each separately on the STAR.CHARGE.USED comment
  line, using the STAR.BUDGET.USED [.USEA] attributes of "bills". Note
  "bills" should be listed under the flag STAR.CHARGE.USED [.USEA] for this
  to happen.

  In order to override the normal estimation of a budget at the end of
  its period, use

  =STAR.BUDGET.MMX <budget account> <minimum> <maximum>

  This will force the estimation of <budget account> to be at least <minimum>
  and no more than <maximum>, unless its actual value is greater than
  <maximum>. Use this flag if you plan on spending at least <minimum> and wish
  to include that in the estimate or plan on spending no more than <maximum>.

  In order to display the aggregate sum for each object not yet processed by
  the bank, specify

  =STAR.OBJECT.TOTAL Y

  or

  =STAR.OBJECT.SUM Y

  for all entries.

  For instance, if you were to specify

  +deposit 100 - first deposit
  +deposit 150 - second deposit

  then the object "deposit" would have its aggregate sum displayed as

  !&$cur deposit    250.00

  immediately after $END.

  A similar total can be done using the directives =STAR.TARGET.DOT
  and =STAR.TARGET.SUM in order to add all targets aggregating
  by category as follows.

  =STAR.TARGET.DOT <dot>

  will define the "dot" or "separator" to be used by this proceedure.
  For instance, "doors.house" will aggregate according to "house" if
  <dot> = "." which also is the default if =STAR.TARGET.DOT is not defined.

  =STAR.TARGET.SUM <target> <category>

  will aggregate <target> by <category>, regardless of the definition of
  <dot>. This is used mainly for defining the default aggregation.
  It is convenient to use the directive =STAR.DEFN.FILE to store these
  default definitions. An example of =STAR.TARGET.SUM is as follows:

  =STAR.TARGET.SUM doors house
  =STAR.TARGET.SUM windows house

  will aggregate the targets "doors" and "windows" according to "house".
  For example, if doors were $100 and windows $200 then

  !&$cur HOUSE                    300.00

  would be displayed. If "doors.house" and "windows.house" were used as
  target names without specifying =STAR.TARGET.SUM, the same aggregation
  would be accomplished.

  Following a leading "#" (which should only occur once) is a space and up to
  five values. The first value is the main account balance, which is
  the actual account balance less the combined star account balances.
  This may be positive, zero or negative, as is also the case with star
  account balances. The second value is the total used across all budget
  accounts and the third value is the total remaining in all budget accounts.
  The fourth value is the sum of all the used amounts for budgets that are
  over their quotas (negative). The last value is the sum of all budgets.

  For example, if we wish to define the starting amounts for the following
  star and main accounts:

     *CREDITCARD  100.25
     *TAXI        -25.00
     &CLOTHES      50.00    10.00     40.00     15.00
     &FOOD         75.00    15.00     60.00     17.00
     #             35.01    25.00    100.00     32.00      0.00  125.00
!                           &used     &left     &etgt     &over &tottgt

  In the above case, there is $100.25 in the star account CREDITCARD,
  negative $25 in TAXI and 35.01 in the main account. The account balance
  (shown below) is $110.26 (35.01-25+100.25). "&etgt" is the estimate
  of how much the budgets will have remaining at the end of the budget period
  taking into consideration the target, the amount spent and how much time
  is remaining. If "&etgt" becomes negative, that indicates how much STAR
  estimates you will overspend your budgets. A positive value is the estimate
  of how much you will underspend your budgets.

  Use =STAR.BUDGET.PRM for setting the limits for this period, using the format
  "yymmdd" for starting and ending dates, such as

  =STAR.BUDGET.PRM 030108 030209

  Note the year above is 2003, starting on January 8, ending on February 9.
  &tottgt (125.00) is the total of all budgets (50+75). In this case, you
  expect to be within your goal of 125.00 with an estimate of 93.00.

  As with any =STAR command that accepts dates of the form YYMMDD as
  parameters, you may use symbolic dates rather that actual dates. These
  symbolic dates need to be defined in a file named TRNLNM.DAT. For instance,

  =STAR.BUDGET.PRM    STAR.SOM star.eom

  would be the same as previously listed above, providing the statements

  star.som 030108
  star.eom 030209

  were placed as separate statements in TRNLNM.DAT.

  The star account CREDITCARD has a positive balance, which can be used
  to pay the credit card bill when it becomes due, assuming the balance
  is sufficient. Since negative balances are allowed by STAR, one star account
  may show sufficient funds, while other star accounts don't, the net result
  might be that there are insufficient funds to actually cover a positive
  star account.

  The star account TAXI has a negative balance indicating that
  the user has overspent his allocated amount for taxi's, which needs to be
  paid back at some time. Changing the value of a star account entails
  simply adding a line starting with the star account name and a value.
  If this value is positive, the star account is increased by the value
  and the main balance is decreased by the same value. If this value is
  is negative, the star account is decreased and the main balance
  increased. Thus the following would subtract $35 from the main balance
  and add $35 to TAXI, resulting in a surplus of $10:

  TAXI 35

  The following line, having been put in STAR processed this file, would
  look like:

!  star accounts= 75.25 balance= 110.26 audit= 105.26 abal= 5.00 ebal= 50.00

  The balance is $110.26, the sum of all accounts. If the total
  balance becomes negative, then there may be insufficient funds
  at some time, as determined by the bank, unless an adequate deposit is made.
  Note that there are sufficient funds to pay the credit card in this case,
  as the main balance is positive. If the main balance becomes negative,
  there still may be sufficient funds to pay the credit card, depending
  on the other star account balances, or, more simply, the account
  balance.

  The audit balance should match the bank statement balance at the time of
  last audit. How to do an audit is explained below. "abal=" is the amount
  of outstanding transactions with the bank.

  There are two budget accounts, CLOTHES and FOOD. Both of this accounts
  are below budget, with $100 remaining. Note all budget accounts may be
  within budget, yet there may be insufficient funds to cover the star
  accounts and/or main balance. If this is not a transitory effect, but
  seemingly a permanent one, you may consider re-adjusting the budgets.

  The "ebal=" value is the estimate (using linear regression) of the
  main balance for a range of dates. In order to define how many balances
  to save and these dates, define the directive STAR.BALANCES.PRM as follows

  =STAR.BALANCES.PRM <#balances> <start_YYMMDD> <end_YYMMDD> <day_adjust>

  Specifying <#balances> will cause the last <#balances> main balances to
  be saved under the format "=STAR.BALANCES". The remaining two parameters,
  if entered, is the date range to be used to calculate "ebal". <start_YYMMDD>
  is the year, month and day to start using balances and <end_YYMMDD> is the
  last date to use. If the number of balances is less than 2, STAR will not
  attempt to calculate "ebal". STAR will also use the balances to calculate
  "premonbal", last month's main balance on today's date adjusted by
  <day_adjust>. If there is no balance recorded for that date, then a linear
  interpolation will be displayed.

  You may edit the values on the "=STAR.BALANCES" line, if you wish to remove
  distortions. The format is YYMMDD followed by the main balances on that
  date and following dates.

  The "eaud=" value is the estimate (using linear regression) of the
  audit balance for a range of dates. In order to define how many balances
  to save and these dates, define the directive STAR.AUDITBAL.PRM as follows

  =STAR.AUDITBAL.PRM <#balances> <start_YYMMDD> <end_YYMMDD> <day_adjust>

  Specifying <#balances> will cause the last <#balances> audit balances to
  be saved under the format "=STAR.AUDITBAL". The remaining two parameters,
  if entered, is the date range to be used to calculate "eaud". <start_YYMMDD>
  is the year, month and day to start using balances and <end_YYMMDD> is the
  last date to use. If the number of balances is less than 2, STAR will not
  attempt to calculate "eaud". STAR will also use the balances to calculate
  "premonaud", last month's audit balance on today's date adjusted by
  <day_adjust>. If there is no balance recorded for that date, then a linear
  interpolation will be displayed.

  You may edit the values on the "=STAR.AUDITBAL" line, if you wish to remove
  distortions. The format is YYMMDD followed by the main balances on that
  date and following dates.

  The estimator "&dpay" provides the difference between the main balance and
  the value of the deflated direct portion of a paycheck. The directive

  =STAR.DEFLATED.PAY  <date YYMMDD of a recent paycheck>
                      <days between paychecks (negative = months) >
                      <direct paycheck amount>

  defines the parameters for "&dpay". For instance, suppose you receive
  a paycheck each 14 days, of which $150.00 is the amount left over after
  all future payments and savings are factored in. This $150.00 is called the
  "direct portion" of your paycheck. The directive would be

  =STAR.DEFLATED.PAY 040301 14 150

  Ideally, you would like the direct portion of your paycheck to last
  proportionally until the next paycheck is received. Thus if 7 days have
  elapsed, ideally you would like to have $75.00 remaining to spend.
  Suppose instead the main balance was $80.00, after taking into account
  all spending during the 7 days. Then "&dpay" would equal $5.00, indicating
  you have $5.00 more to spend, if you wished. Now suppose the main balance
  were $10.00. In this case "&dpay" would equal -$65.00, indicating you had
  overspent $65.00. Of course, if your refrained from any further direct
  spending for the remaining 7 days, you would make up this difference.

  The next section of a STAR file is the audited section. This is activity
  that the bank has acknowledged. This section ends with the line:

  $EOS

  for "end of statement". Activity entered here will be processed by STAR
  as part of the audit balance, which then should match the bank's statement
  balance.

  After the audit section comes the unaudited section, terminated by

  $END

  for "end of unaudited section". Activity entered after $END (archive section)
  will not be reflected in the audit balance, when processed by STAR. Perform
  regular maintance on the STAR files once a month or quarter, by deleting the
  oldest records after $END. Otherwise, STAR may run out of memory when
  processing the input file. STAR can handle 1000 archived records. From a
  budget point of view, the records older than the current monthly cycle
  should be removed.

  The rest of the file after $END should be used for previously processed
  activity, acknowledged by the bank, that is being kept in the file to be
  solely part of the budget computation. When such an item is no longer to
  be considered part of the budget computation, either delete the item or
  replace the "%" with an "!".

  You can have a budget column for current expenses by inserting "$CUR
  anywhere in the transaction list. This toggles on and off the current
  amounts if placed multiple times. You can also define the directive
  STAR.CUR.DATE <yymmdd> to keep track of the latest expenses. The directives
  STAR.CUR.FROM <yymmdd> and STAR.CUR.TO <yymmdd> are also available.
  STAR.CUR.DATE automatically updates whenever new expenses are added and
  adds the column "&$cur" of latest budget expenses. An example would be:

  =STAR.CUR.DATE 020115

  =STAR.ALERT.YYMMDD <yymmdd> <text> compares the current date against
  <yymmdd> and if greater or equal, outputs <text>. This might look like:

  =STAR.ALERT.YYMMDD 020120 make sure car payment was sent

  In which case, on or after January 20, 2002, the message
  "make sure car payment was sent" would appear each time STAR was run.

  If you wish to be alerted in advance (or after) the date, enter a "-"
  (or "+") after the date followed by the number of days, such as

  =STAR.ALERT.YYMMDD 020120-2 medical appointment with Dr. Smith

  which would start alerting you 2 days before the actual appointment.

  Sometimes it is advantageous to store directives in their own file,
  for easy reference. Use the directive STAR.DEFN.FILE <filename> for this.
  For instance, suppose there is a certain group of alerts that are more
  manageable if grouped together, such as payment alerts for a certain
  project X. Then specify

  =STAR.DEFN.FILE C:\STAR\PROJECTX.TXT

  where the file PROJECTX.TXT would contain all the alerts for project X,
  entered just as they would be in the main STAR file.

  =STAR.CHK.LEAD.CMD <Y/N> turns on/off checking of the leading indicator
  for budgets/star accounts in the remarks section for commands (non-macros).
  If this is entered after EOS, it will be temporarily used once only.
  Use STAR.CHK.LEAD.MAC <Y/N> for macros. The default is "Y" for commands
  and "N" for commands. An example:

  =STAR.CHK.LEAD.CMD Y
  =STAR.CHK.LEAD.MAC N

  =STAR.EARN.BUDGET <Y/N> turns off/on normal budget processing as
  described in the rest of this manual. If normal processing is turned
  off ("Y") then a report will be produced showing net, revenue and expenses.

  The leading symbol "!" can be used for comments anywhere in the file,
  althought it generally is not necessary to use this symbol, as
  any comments will be interpreted as such if they do not occur
  where data is expected. "!" should not be used when data is expected
  except in well-documented cases where "!" is ends the data.

  "!" is for freeform text at the end of a line, in contrast to leading "%"
  items that represent previously considered activity that must adhere to the
  required format and are still used to compute budget account balances.

  In addition, an activity line may have comments added to the end of that
  line. STAR will ignore any excess data on a line, after it has fulfilled
  its requirement for processing that line. In cases that are ambiguous,
  a comment string must start with a character other than a digit, "+",
  "-" or ".".

  You may have a message appear on the screen when an activity line is executed
  by entering

  star.message="<message>"

  where <message> is any string with single "s. A " may be in <string>
  if it is represented as "".

  For instance:

  +deposit 1000 *account - star.message="check that this deposit is credited"

  will display the message "check that this deposit is credited" when
  executed.

  The entry of activity in both the audited and unaudited sections
  is based on the leading (first) character and the number of words,
  comments not included, to wit:

  If there is only one word on the line, it is assumed to be an
  simple internal addition or subtraction. This means it does not effect the
  bank balance. It is useful for moving amounts between multiple star accounts
  using one line. The allowable first characters are a number or a "+" or
  a "-". A leading "." has special meaning as explained below, and should not
  be used to enter additions or subtractions of less than a dollar. Use a
  leading "0.". Here are some examples:

  +100 - comment - this does nothing as no star accounts are specified
  -50 *food - subtracts $50 from main balance and adds to *food (star account)
  100 *car - adds $100 to main balance, taking from *car
  0.34 *food=-0.15 *car - $0.34 to main balance, $0.15 from food rest from *car
  150 &misc - adds $150 to budget account misc (spent somewhere else)
  -50 &misc - subtracts $50 from budget account misc (received somewhere else)

  The last two examples above shows an alternate way to add or subtract from
  budget accounts, using transactions that do not effect the main balance of
  the current STAR file. This then would superceed the discussion below
  concerning the addition of a "B1" record below.

  An example using the "@@" translation described below would be to define
  "deposit_misc" as follows:

  @@deposit_misc <amount> &misc <*>

  This done, one could give the command:

  deposit_misc 100 - this is a miscellaneous deposit

  Although it appears to be a non-internal operation, it actually is
  executed as follows:

  100 &misc - this is a miscellaneous deposit

  making it an internal operation adding 100 to the budget account "misc",
  without effecting the main balance.

  In order to effect the bank balance, use "named" main
  account notation (using 2 words) as described next.

  If there are two words on the line (the maximum allowed), then
  this activity is one of the following:

  If the first character is a "+" or a "-", then this is "named" main account
  activity, which is the correct way to represent such activity
  in lieu of the preceeding single word entry described above.
  Some examples:

  -BANKFEE 10 - bank subtracted $10 from your balance
  +INTEREST 2.34 - bank credited you $2.34
  +DEPOSIT 25 - you deposited $25

  If the first character is a number, it is assumed to be a check
  number. This should be followed by a space and the amount. Here
  are some examples, for checks 405, 406 and 407:

  405 25.23
  406 100
  407 .1

  If the first character is a letter, it is assumed to be a star
  account. This should be followed by a space and the amount, either
  positive or negative. A positive amount represents an addition
  to the star account, while a negative one, a subtraction. You may
  enter star account activity at any time without effecting the balance.
  Some examples:

  CREDITCARD 10.23
  TAXI -3.25

  In the first case, $10.23 is to be subtracted from the main account
  and added to the star account CREDITCARD, while $3.25 is to be added
  to the main account, and subtracted from the star account TAXI.
  When it is time to pay off the credit card (suppose it is $10), enter
  the activity as a negative:

  CREDITCARD -10

  In this case, you will have $0.23 left in this star account (ready to
  be used for the next bill) and $10 more in your main account, to
  be used for writing a check to the credit card company.

  In order to replace a star account amount with a new amount,
  add "^" to the replacement amount. The following example will
  replace whatever is in CREDITCARD with $150:

  CREDITCARD ^150

  Recurring expenses can be saved for in advance by adding a fixed
  amount on a regular basis to a star account. When it the expense
  becomes due, the anticipated amount (a multiple of the additions)
  should be withdrawn from the star account. This may not be the
  actual expense and it may not exactly equal what is in the star account,
  but what is important is over the long term the withdrawals from the
  star account equal the deposits. In order to accomplish this, there
  is the notion of "default" withdrawal (or deposit), which should be the
  anticipated amount.

  For instance, suppose each time you receive your weekly paycheck,
  you deposit $25 in a star account called "ELECTRIC", making the
  anticipated amount $100. (This could be done automatically using
  the concept of "macro", explained below.) When the electric bill
  comes due, you should remove $100 from ELECTRIC, regardless of
  how much is there, as over the long term the deposits will equal
  the withdrawals.

  Define the star account with this amount contained in paratheses as follows:

  *ELECTRIC(100) 75

  When the bill arrives (say for $105.20), pay the bill with a check.
  say number 520 and withdraw the anticipated amount $100 from ELECTRIC.
  This would look like:

  520 105.20 *electric

  This is equivalent to the following (with the advantage one does not
  need to remember the anticipated amount):

  520 105.20 *electric=-100

  Note ELECTRIC will have a negative balance of -$25.00, which will be
  made up with the next paycheck, say in a few days. If you are regularly
  adding to a star account, say with each paycheck, and you wish to subtract
  from that star account when the bill arrives, while making the yearly
  additions and subtractions to the star account equal, use the included
  program PCD to figure how much should be currently in reserve. The included
  PCE program will also help in determining the initial setup.

  Another approach to anticipating future expenses is to specify a
  minimum negative amount a given star account can have, removing
  as much of the bill as possible without going below that minimum
  negative amount. The replenishment of the star account would not
  necessarily be done on a fixed predictable basis in this case.
  To do this, specify a negative amount in parentheses as follows:

  *ELECTRIC(-25) 75

   In the above case, ELECTRIC would never go below -$25 when
   using default withdrawals. Thus if the bill were $80, ELECTRIC
   would have a negative $5 balance and if the bill were $110, ELECTRIC
   would have a negative $25 balance, not negative $35.

  If the first character is a ".", then this represents an outstanding activity
  that has yet to appear on the bank statement, but reflected
  in the star accounts and main account and balance, but not in the audit
  balance.  Here are some examples:

  .+DEPOSIT       110
  .-ATM            75
  .401 30

  In the above case, the balance contains an extra $5 that is not reflected
  in the audit balance.

  If the first character is a "%", then this represents activity that is
  now included in the bank statement or audit balance. Generally, the "%"
  should be applied to activity that already has been processed and now
  is being acknowledged by the bank. Putting a leading '%' on unprocessed
  activity will result in an item failing to be processed for balance purposes,
  except for budget balances. If this is the case, the STAR formatting must
  be adhered to, with the second argument being the value followed by the
  third+ arguments possibly beginning with the budget designation "&".

  budget accounts are entered on the same line as the activity that
  effects them. The leading character of a word referencing a budget
  account must start with a "&" (or "@"), with other comments also allowed.
  For instance:

  120 23.45 &FOOD - supermarket for dinner

  In the above case, check number 120 in the amount of $23.45 would be
  subtracted from the budget account FOOD. This is different from a star
  account, in that the main balance would not be effected.

  In order to split the activity amongst several budgets specify the
  amounts as follows, with the default budget (without "=xxx.xx")
  being given the remainder:

  406 100 &hotfood=25 &coldfood=35 &otherfood - shopping

  In this case, the remaining amount, $40, would be associated with
  the default budget "otherfood". It is not necessary to have a
  default budget. The sum of the budget associations can not exceed
  the total activity. Spaces are not allowed before or after the "=".

  Star and budget account activity can be mixed on the same line, with
  star activity effecting any budget activity that follows it. For
  example

  -debit 106 *tax=-6 &toys

  will use $100 for the budget account "toys", while

  -debit 106 &toys *tax=-6

  will use $106 for "toys".

  Inorder to update a budget account without entering activity, use
  a leading "&" with the budget name followed by "=", such as

  &warmfood=23.50 - more shopping

  Note: A leading "&" without an "=" would represent the budget quota.
  Also comments and budget calculations must be placed in columns 34
  and higher on lines that begin with "%". If you process a line item,
  the result will adhere to this format.

  Star accounts can be manipulated the same manner, with the use of
  a leading "*" (or "@") instead of "&". For instance,

  408 120 *savings

  would subtract 120 from savings, making the main debit 0, while

  408 120 *savings=-100

  would subtract 100 from savings, making the main account debit 20. Thus

  408 120 *savings=100

  would add 100 to savings, making the debit to the main account 220.

  Percentages can be used, such as

  +deposit 212 *sales_tax=6%% *expenses=100 *income_tax=32.5% *profit

  which will add $12 (6% included in the total - double %) to *sales_tax,
  add 100 to *expenses and calculate 32.5% of the remainder to put in
  *income_tax, leaving the rest for *profit. budget accounts are
  interchangable with star accounts in the above. One caution, some
  default calculations like the above will not give consistent results
  if the star accounts involved generated exceptions initially.

  This manner of manipulating star accounts is an alternate to entering
  the star transaction on a separate line.

  Star accounts may be computed in a hierarchical manner of parent and child
  using the following command

  =STAR.SUBACCOUNT <x> <y>

  where <x> is a single letter and <y> is either Y, Z, A, or N.
  This will allow the building of trees of star accounts that obey the
  following rules:

  1) A star account name (called a parent) will be the sum of all accounts that
     use the same name followed by <x> and further letters, called the children.
  2) If a positive value is added a parent star account, then that value will
     be distributed equally across all children that are non-negative,
     if any, otherwise all children.
  3) If a negative value is added a parent star account, then that value will
     be distributed equally across all children that are negative.
  4) If a value is added to a child, then it is also added to the parent.

  If <y> is "Y" or "Z" then all parent accounts that are zero will be adjusted
  to their default values. If <y> is "A" then all parent accounts will be
  adjusted to their default values. If <y> is "N" then no parent account
  adjustment will be made. This allows you to specify the definition of the
  values of childern star accounts without specifying the definition of the
  parent's value. Caution: If you allow parent account adjustment and multiple
  parent accounts need adjustment, star may take mutiple passes to adjust all
  the parent accounts, which will require execution of STAR multiple times to
  properly define all parent accounts.

  For example, assume you earn money from 2 day-time jobs and 3 night-time jobs.
  They you could have the following star accounts

  =STAR.SUBACCOUNT "." Y

  *PAYCHECKS        11000.00
  *PAYCHECKS.DT      5000.00
  *PAYCHECKS.DT.1    4000.00
  *PAYCHECKS.DT.2    1000.00
  *PAYCHECKS.NT      6000.00
  *PAYCHECKS.NT.1    1000.00
  *PAYCHECKS.NT.2    2000.00
  *PAYCHECKS.NT.3    3000.00

  Adding $1000 to PAYCHECKS.NT.2 would add that amount to PAYCHECKS.NT
  and PAYCHECKS automatically.

  If you wish to use an alternate naming convention for individual accounts
  use the directive:

  =STAR.ACCOUNT.SUM <accnam> <sumnam>

  where <accnam> is the account name that is used and <sumnam> is the
  name to be used for purposes of summing accounts. For instance,
  suppose you wish to use the account name PAYCHECKS-DT instead
  of PAYCHECKS.DT in the example above. Then define

  =STAR.ACCOUNT.SUM PAYCHECKS-DT PAYCHECKS.DT

  and the display above would now look like

  *PAYCHECKS        11000.00
  *PAYCHECKS-DT      5000.00
  *PAYCHECKS.DT.1    4000.00
  *PAYCHECKS.DT.2    1000.00
  *PAYCHECKS.NT      6000.00
  *PAYCHECKS.NT.1    1000.00
  *PAYCHECKS.NT.2    2000.00
  *PAYCHECKS.NT.3    3000.00

  Any activity that contains either a budget reference or comment is
  automatically saved in the output file, either with a leading "."
  for activity not yet included in the audit balance or with a leading "%"
  for activity already included in the audit balance.

  The budget accounts are calculated using all activity items, regardless
  of whether or not they have already been included in the audit balance.
  Maintenance of the budget accounts is achieved by deleting the activity
  items or removing references to the budget account.

  =STAR.AUTO.PAY <name> [ (<initial balance>) ] <#deductions/yr> <#payments/yr>
                       <payment amount> <deductions to date> <payments to date>
                       <comments>

  will associate two values with a string <name>, which is usually the
  name of a star account. The first value is a dollar amount D and the
  second a dollar amount P so that

       D * <#deductions/yr> + <initial balance> = P * <#payments/yr>

  such that P is as close to <payment amount> as possible. These two values
  can be used as follows. If "expenses" is a star account, then the command

  expenses (<name>)

  will add D to "expenses", subtracting D from the main balance. The command

  *expenses(<name>)

  will define the default value for "*expenses" to be P.

  If the definition of "expenses" is "*expenses(<name>) value" then
  the default for *expenses will be using "<name>", that is, P. In the
  previous example involving the account "electric", this is not an
  autopay account as its definition is a constant value (100 or -25),
  not an =star.auto.pay name.

  (<initial balance>) should be omitted if there is no starting balance
  before each payment. If (<initial balance>) is specified as non-zero,
  when a payment is made, it is assumed the (<initial balance>) will be
  replenished from some other source other than a regular deduction.
  Thus the associated star account should always have at least
  (<initial balance>) when beginning a payment cycle. If you wish
  (<initial balance>) to be a one-time balance used for multiple payments,
  simply zero it out after the first payment.

  If <#payments/yr> is zero or less then this is a special case in which
  <#payment amount> is considered to be the total amount to be paid over
  <#deductions/yr>. Each time a deduction is made, <name> is credited with
  <#payment amount>/<#deductions/yr>. Each time a payment is made, <name>
  is debited the full amount of the payment. At the end of the cycle (when
  <#deductions/yr> has been reached), a message is given to alert the user
  to reconcile <name>, as it may be non-zero. If <#payments/yr> is negative,
  the positive represents the number of yearly payments. The purpose of this
  case is to allow for bills that come in at random times and/or are for
  very different random amounts but for which the yearly total is approximately
  known. Care should be taken when using this option, as <name> could
  become sufficiently negative so as to render the entire account negative.
  Good examples of this special case would be for fuel oil or electricity
  bills. After the expense has been billed for one year, use the program
  STARS.EXE to estimate the average yearly number and amount of each
  payment, which should be entered in <#payments/yr> and <#payment amount>
  repectively. Enter the star account name followed by a zero and execute STAR
  to automatically adjust the star account value. Finish by re-setting
  <#payment amount> to the total yearly estimate and <#payments/yr> back to
  zero. This proceedure should then be repeated quarterly thereafter.

  If the string "star.alert=<value>" is embedded in <comments>, then
  an alert will be given when <deductions to date> equals <value>. Only
  one instance of this feature is supported.

  If the string "star.execute=<command>" is contained in <comments>, then
  <command> will be executed after an embedded reference to the star account.
  You may use quotes to enclose <command> if it contains spaces, otherwise use
  a macro, as explained below. If you wish to restrict the execution to
  only deduction references, use "star.execute.ded=<command>" or for payments
  only, "star.execute.pay=<command>".

  If the string "star.quiet" is contained in <comments>, then the message
  "- balance adjusted by ... by autopay ..." will be surpressed

  Now suppose you have a bill (carpay) that comes in regularly once a month
  for about $58 and you are paid bi-weekly. Suppose you wish to accrue for
  this bill each time your paycheck arrives and pay the bill each month with
  the accrued money. Suppose you have received 10 paychecks and have made 5
  payments, so far. Define in the header section, with <name> = carpay and
  star account = carpay.

  =STAR.AUTO.PAY carpay 26 12 58 10 5

  Also as <name> is the same as the star account name, you could have entered

  *carpay()

  instead of

  *carpay(carpay)

  When you are paid, you might enter the command

  carpay (carpay)

  or

  carpay ()

  which will add 26.76 automatically into carpay, equivalent to

  carpay 26.76

  However, "carpay 26.76" will not have the same effect as "carpay ()"
  or "carpay (carpay)". "carpay 26.76" will not be recognized as an
  deduction to the carpay account. In fact, if star.auto.fix is
  on, then this will have the only effect of verifying the
  amount in carpay, thus having the same effect as "carpay 0".
  If star.auto.fix is off, then carpay will be increased by 26.76
  but again <deductions to date> to carpay will not be changed.
  "carpay (26.76)" will add 26.76 to carpay and increment
  <deductions to date> for the star.auto.pay definition "carpay". Unless
  <#payments/yr> is zero, the balance in carpay will be verified.
  In this case, if star.auto.pay.fix is on, carpay will be appropriately
  adjusted making "carpay (26.76)" to have the same effect as "carpay ()".

  When it comes time to pay the bill of say 58.23, say with check 504, enter

  504 58.23 *carpay

  and 57.98 will automatically be removed from carpay to pay the bill. Note

      57.98 * 12 = 26.76 * 26

  so over one year's time, the money you accrue will exactly equal
  the money you used from the accrual to pay the majority of the bill.
  The numbers 57.98 and 26.76 are automatically computed by STAR. The
  program PCD is included in the release of STAR, which will compute
  how much there should be in reserve now, starting from some predetermined
  point in time, such as the beginning of the fiscal year, which is
  usually the calendar year for individuals. When setting up autopay
  initially for payments that are on a yearly schedule, use the included
  program PCE to determine how many paychecks there are to the payment,
  setting autopay to the number of yearly paychecks less the number of
  paychecks remaining.

  If you wish to add the "<payment amount>" for carpay into the main balance,
  enter

  star# 0 carpay*

  The special star account name "star#" represents the main balance and should
  only be used in this context.

  The use of (<initial balance>) is most useful for one-time payments for which
  some money is already achieved before starting the deduction process
  to build up to the payment. For instance:

  =STAR.AUTO.PAY buynewcar (1000) 36 1 10000 5 0

  would imply you are saving for a new car costing $10000, that you
  have $1000 already saved and wish to save for the remaining $9000
  over a period of 36 paychecks, having already received 5 of those
  paychecks. This then would entail saving $250 each paycheck rather
  than $277.78. In the case here, the associated star account would
  have $2250 = $1000 + $250 * 5 in it.

  Autopay can also be used for income averaging. Suppose you receive
  income on a regular basis of predictably varying amounts. In order
  to normalize this income stream, define

  =STAR.AUTO.INC.AVE <name> <income1> ... <incomeN> <income place>

  where <name> is the name of this income averaging scheme, usually
  the name of its associated star account, <income1> ... <incomeN>
  are the various amounts of income received in a complete cycle of N
  payments and <income place> is the current place in the cycle. The
  associated star account is defined similiarly as in the case of
  =STAR.AUTO.PAY, described above. An example would be

  =STAR.AUTO.INC.AVE reserve 1000 1100 1100 2

  which would imply you regularly receive $3200 in three paychecks of
  $1000, $1100 and $1100, which then repeat in that order. The cycle
  size here is 3 and you are currently at income2 in the cycle. The
  <income place> may be greater than the cycle size, in which case
  it will be reduced automatically by the program to a number within the
  cycle to determine the current income place.

  Define "reserve" to be the associated star account as follows

  *reserve()   33.33

  The correct amount to be contained in reserve can be obtained from PCA.EXE,
  which also shows that upon receiving income3 another $33.33 will be added
  to reserve, bringing the amount in reserve to $66.66. When you receive
  income4 (income1 in the cycle), $66.66 will be subtracted from reserve,
  leaving it at 0. Thus each paycheck you receive has the effect of being the
  same, approximately $1066.67, the average of the three paychecks. The
  following discussion below of autopay accounts also apply to income averaging.

  For autopay accounts it is sometimes useful to use a paid amount
  different from what would normally be used for the default.
  Use "("and ")" in this case. For example

  general_funds 1000 *toys=-100 *carpay=(150) *clothes=-200 *remainder

  will put $1000 in general_funds, taking $100 from toys, the default amount
  from the autopay account carpay and $200 from clothes.

  STAR will use $150 as the amount contributed from carpay rather than $900
  ($1000-$100) which would have been the case if only "*carpay" had been
  specified. Since carpay is an autopay account, further calculations will be
  done to provide this $150. If the autopay for carpay is $149, then only $1
  ($150-$149) will be listed as being deducted from the main balance rather
  than $751 ($900-$149). This effects the final deduction from "remainder".
  In the first case, it is $550 that is deducted and in the second case,
  it is $200 that is added to "remainder". Basically, there are two separate
  levels here. One is the calculation from one account to another and the other
  is how each account handles what it is responsible for.

  In order to be able to use the default amount from the autopay account carpay
  without specifying it, the symbol "()" has been given a special meaning, as
  follows: if "carpay=()" is specified, then one both levels, the default amount on both
  is used. Thus is our example, "carpay=()" would be treated as "carpay=-149".

  By default, any errors detected for a star account that is listed
  as STAR.AUTO.PAY will cause the program to halt, unless the flag statement

  =STAR.AUTO.PAY.FIX Y

  is specified. If this flag is set to "Y" and a star account action
  is given, then the correct amount will be loaded into the star account.
  If you wish to correct an error concerning the star account "carpay"
  due to a change in its STAR.AUTO.PAY parameters, enter

  =star.auto.pay.fix y
  carpay 0

  Note: autopay accounts must match their STAR.AUTO.PAY parameter settings.
  Thus to change the amount in such an account, one must change both the
  parameters and the account, in unison. Using =STAR.AUTO.PAY.FIX will
  automatically adjust the account according to the new STAR.AUTO.PAY settings.

  In order to verify the correct autopay amount is being used, specify

  =STAR.AUTO.PAY.VER Y

  In order to set the parameters for checking if auto.pay accurals and payments
  are within range, use

  =STAR.AUTO.PAY.PRM <accruals_difference> <payments_difference>

   For instance, if there are 32 accruals for an auto.pay account that has
   26 accruals for the cycle and <accruals_difference> is less than 6, then
   an error message will be given. The default for both parameters is 5.

  In order to allow checks to be immediately deducted from the audit balance,
  (cashing of your own checks), enter the flag

  =STAR.CASH.CHECKS Y

  Otherwise the error message "cash transaction after EOS" will occur.

  In order to reverse budget reporting, enter the flag

  =STAR.NEG.BUDGET Y

  For verbose output without using the switch "/v", enter the flag

  =STAR.VERBOSE Y

  In order to allow duplicate check numbers, enter the flag

  =STAR.DUP.CHK.NBR Y

  For embedding the sort order, enter

  =STAR.SORT <sort> <leadchr>

  where <sort> is 0 to +-4. If sort is not 4, then the first word
  followed by the date, followed by the rest is used. If <leadchr>
  is specified, then the first word with leading <leadchr> character
  will be used.

  =STAR.SORT <sort> [a:b]

  will sort inside the field <sort> by positions a:b.

  =STAR.SORT <sort> [a:b] <sort2> <leadchr2>

  combines the two above in the order as presented.

  Paying back or saving for one-time bills over time:

  Suppose you have a one-time bill which you wish to pay back from a star
  account over a period of time, a fixed amount each pay period.
  The command

  <account> (<pay>,<maximum>)

  will add <pay> into <account> and alert you if <maximum> is reached.
  Only enough to match this <maximum> will be applied.

  As an example, suppose you bought a TV for $500 and wish
  to pay for it over a period of 10 paychecks, which would be a deduction
  of $50 per paycheck. Initially, you would create a star account called
  say, "tvpay" with a value of -500. For instance,

  tvpay -500

  Each pay period, you would then enter the command

  tvpay (50,0)

  Alternatively, you could define typay as

  *typay(50,0)

  After 10 pay periods, you would be alerted that tvpay was at
  maximum. This same method could be used to
  save for the TV, by adding 50 per pay period into a star
  account that was initially zero by entering the command

  tvpay (-50,500)

  When tvpay reaches 500, you would be alerted. Note the negative value
  when the account is to be added to rather than subtracted.

  Creating a macro that is executed each pay period is an easy
  way to implement both methods () and (,) of processing a star account,
  as explained below.

  Macros:

  Following a leading "@" is the macro name, which is used to match the first
  argument on an activity line. After the macro name comes the command to be
  executed, which can be any other activity line. For instance,

  @+deposit_paycheck      newcar    100   - put into savings for new car
  @+deposit_paycheck      computer   50   - put into savings for computer

  would add $100 automatically into the star account "newcar" and $50
  into "computer" whenever "+deposit_paycheck" was stipulated as an
  activity. If you wished to use STAR.AUTO.PAY to handle the bill carpay
  as explained above, you could enter the macro:

  @+deposit_paycheck      carpay   (carpay) - deduction for carpay
  @+deposit_paycheck       tvpay     (50,0) - pay back TV alert when paid off

  A double "@@" is also a macro name, with the difference that the command
  that invokes it does not itself execute. Only the translated command
  executes. Parameters to the macro are filled in left to right order
  to strings of type <parameter> in the macro definition. For instance
  suppose the macro definition was

  @@deposit_gift  +deposit_gift <amt> <exp>  *gifts2=<exp> *gifts1=50% *gifts2

  and the invoking command was

  deposit_gift 100 50

  The command actually executed would be

  +deposit_gift 100 *gifts2=50 *gifts1=50% *gifts2

  which would first add 50.00 to gifts2 then add 25.00 to gifts1 and the rest
  (25.00) into gifts2. Any extra parameters to the invoking command are ignored.
  The special symbol "<*>" represents all remaining parameters as a single
  string with no further fill-ins of type <parameter> processed. The special
  symbol "<*[star_account]>", where "[star_account]" is a star account name,
  represents the value of that account. This allows star accounts to be used
  as "registers" for ongoing computations and account transactions.

  For instance, the following commands compute an amount, based on the
  parameter <amt>, adds the amount to the star account ltdebt, then transfers
  that amount, shown follows:

  @@DEPOSIT_INT        +int <amt> *simitx=28.84% *simcti=7.02641934% *ltdebt - .esave979
  @@DEPOSIT_INT        -transfer <*ltdebt> *ltdebt

  Note: the following command would be disallowed as an ambiguous macro usage:

  +deposit_gift 100 50

  However, this would prevent imbedded @@macros from being used such as

  @@DEPOSIT_GIFTS     deposit_gift 100 50

  In order to deal with this, the "@" directive may be used as follows:

  @@DEPOSIT_GIFTS     @deposit_gift 100 50

  This will cause STAR to execute "deposit_gift" as a valid macro when
  deposit_gifts is executed, instead of rejecting it as ambiguous. This
  allows multiple macros to use a single macro as the basis of the execution.

  The MACRO qualifier "star.run=n" is implemented, where "n" is the number
  of times the macro is allowed to be run. For instance,

  @+DEPOSIT       PAY       167.64 - repay in june star.run=1

  will run once only. Changing the qualifier to "star.run=0" will
  prevent it from running and "star.run=2" will allow it to run twice.

  Preventing the display of commands:

  Enter the string "star.no.write" in a command to prevent it from being
  written to the STAR file. For instance,

  +star.no.write 0 *~account=2000-*~account

  will make ~account equal to 2000 without leaving a transaction record.
  This parse command is good for calculations that result in *~account
  values. It is not recommended for calculations or transactions that
  affect balances, as those need to have an audit trail.

  Keeping track of your future balances without the use of "ebal":

  The STAR command

  =STAR.FUTURBAL.PRM <days> <max_history> &date=<yymmdd> remcom remcma audcom
                                maxdif=<maxdif> maxpdf=<maxpdf> maxndf=<maxndf>

  will set the default number of days between STAR.AUTO.PAY payments to <days>
  for the proceedure =STAR.FUTURBAL as explained below. "<max_history>" is
  the maximum number of historical items that will be stored in the display
  "star.history=(amt1^date1 amt2^date2 ... amtn^daten)". <max_history> must be
  at least 1 to enable this history and is recommended to be set to 3,
  otherwise there could be a fatal memory overflow if other fields are large.
  The parameter "&date=" is optional and if it is specified, <yymmdd> will be
  used instead of today's date to determine which of the =STAR.FUTURBAL
  &<auto>'s will be executed. You may use "000000" or "00000000" instead of
  <yymmdd> as a placeholder.

  "remcom" will cause complete transactions to be
  removed from the list, if the completion date is today or less. "remcma"
  is the same as "remcom" except it only applies to "comauto" status.

  "audcom" will make completed auto transactions that otherwise would be listed
  as audited.

  "maxdif=<maxdif>" will compare the latest value of a non-star account
  transaction to the previous value and create an alert if the absolute value
  of the difference is greater than <maxdif>. The same is true if the actual
  difference is greater than <maxpdf> or less than <maxndf>.


  =STAR.FUTURBAL <due_date> <balance> <amount> <account> <last_bill_date> <qual>

  will keep track of your future daily bank balance <balance> sorted by
  <due_date> using the amount <amount> of the last transaction and the
  account of description <account>. <account> can be a star account with
  a leading "*", a star command (left-to-right, no spaces) with a leading "@",
  an automatic transaction with a leading "&" or a description of the
  transaction. If you want the transaction to execute immediately regardless
  of date, use a leading "%".

  An automatic transaction is of form "&<auto>" where <auto> is either
  a star account or a description of the transaction. If the <due_date>
  is less or equal today's date, the transaction will automatically
  execute, either crediting or debiting either the star account or the
  main balance, depending on the nature of <auto>. If the &date parameter
  is specified in =STAR.FUTURBAL.PRM, then <yymmdd> will be used instead
  of today's date to determine which <auto> will be executed.

  The <amount> should be negative for debits and positive for credits.
  STAR will automatically update <due_date> if <account> is an autopay
  star account. However, control of the <due_date> update is principally
  controled by <qual>, which takes precedence. If <qual> contains the key
  word "star.days=<key>" where <key> comes from the following list, then
  updating of the <due_date> will follow the meaning of <key>.

  Here is the list of possible values of <key>:

  COMPLETE, COMAUTO, ONETIME, DAILY, WEEKLY, BIWEEKLY, MONTHLY, BIMONTHLY,
  QUARTERLY, SEMIYEARLY, YEARLY, FOREVER

  XXX = DAILY-YEARLY  has two options: XXX.A(DD) and XXX.B(DD)
  XXX.A uses the first weekday on or before the computed day.
  XXX.B uses the first weekday on or after the computed day.
  The "(dd)" is optional, which fixes the day "dd" of the month and must be
  between 1 and 31. 31 is always interpreted to be the last day of the month.

  The prefix EVERY<number> may be used with:
  DAYS, WEEKS, MONTHS, YEARS, such as EVERY4WEEKS. This is useful for
  those events that occur multiple times in the look-ahead period, allowing
  them to be scheduled in groups that "leap-frog". For instance, if
  there is an event occuring every two weeks, use EVERY4WEEKS for two
  scheduled events, spaced two weeks apart.

  If you use COMPLETE, COMAUTO or STAR.CONSOLIDATED is used, the balance will
  not be updated otherwise, if <due_date> is less than today's date, a "*" will
  be added after the balance. In order to preserve a transaction for future
  reference that has already complete without having the balance updated,
  enter COMPLETE. COMAUTO is used when an auto transaction completes.

  STAR.CONSOLIDATED can be used when the bill is charged to a
  credit card. There will be no updating of <due_date> unless <account> is
  a autopay account or one of the above key words are used, other than COMPLETE.
  <due_date> will always be updated to never be less than today's date when
  "star.days=<key>" is specified (other than COMPLETE).

  FOREVER will cause the transaction to remain on the FUTURBAL queue
  after it has executed with today's date as the next <due_date>.

  If <account> begins with a "=" then the rest needs to be one of the following
  key words:

  STAR.ALERT.LT, STAR.ALERT.LE, STAR.ALERT.EQ, STAR.ALERT.GE, STAR.ALERT.GT

  If the balance if less, less or equal, equal, greater or equal, or greater
  than <amount> then an alert is issued.

  An alert can also be programmed based on the <due_date> and today's date
  by using the key word "star.alert" or "star.alert=<offset>". In the first
  case, if the <due_date> is less or equal today's date an alert is issued.
  If "<offset>" is specified, then <due_date> will be offset by <offset>.
  For instance sepcifying "star.alert=-1" will alert one day before the due
  date. The message will print out from <account> through "star.alert",
  allowing an additional message to be inserted before "star.alert".

  Some examples:
  (The "- star.days should be placed at the end <last_bill_date>)

=STAR.FUTURBAL.PRM  14
=STAR.FUTURBAL      080719      2548.08      -135.70 *HOUSE              080619
                                          - star.days=monthly star.consolidated
=STAR.FUTURBAL      080811      -583.68     -1787.84 *C                  080607
=STAR.FUTURBAL      080813      -753.83      -170.15 *TAXES              080713
                                          - star.days=yearly
=STAR.FUTURBAL      080816      1593.47       -60.70 new shoes           080716
=STAR.FUTURBAL      080816      1603.47        10.00 @+deposit_gift      080718
=STAR.FUTURBAL      080901      1113.35       120.00 &*pension           080720
                                          - star.days=monthly
=STAR.FUTURBAL      080910      1233.35         0.00 =STAR.ALERT.LT      080716
=STAR.FUTURBAL      090115      5897.34      1527.41 *REFUND_JO1         090108
                                          - transfer in jo1 star.alert

  STAR compatible programming language PCALC:

  The following flags are implemented in STAR to evoke the PCALC programming
  language compiler, which is an implementation of the CALC formula processor.
  The PCALC language provides for CALC computations involving STAR variables
  and has the ability to issue STAR instructions. PCALC also has full access
  to regular CALC computations. See the documentation included with PCALC.EXE
  for a full description of the PCALC programming language.

  =STAR.PCALC  <starting PCALC program address> [ ( args ) ]

  this will evoke the PCALC interpretative complier at the starting
  address specified, which is a file, with possibly a starting module and
  label specified. The optional "( args )" argument can be used to pass STAR
  values to the PCALC module. This is executed immediately after the entire
  STAR input file is read. For instance,

  =STAR.PCALC    C:\STAR.PCL

  would evoke the PCALC complier, starting at the first line of the PCALC file
  STAR.PCL. While

  =STAR.PCALC    C:\STAR.PCL ( x = 10 , y = <val> )

  will do the same, but assigning the value 10 to the STAR.PCL local variable
  x and "<val>" (filled in by STAR) to y.

  As an another example

  =STAR.PCALC  C:\STAR.PCL\MODULE3+LABEL4

  would commence execution in the same file, but at LABEL4 of MODULE3.

  It is important to note the generic flag "STAR.PCALC" begins PCALC execution
  after all other STAR processing is completed. In order to execute at a
  different time, the following specific flags are provided:

  =STAR.PCALC.NOW    <starting PCALC program address>

  This will begin PCALC processing immediately, as soon as this statement
  is encounted by STAR. It is the only flag that evokes PCALC without being
  stored in the STAR output for later execution the next time STAR processes
  the file. In order to store it for execution later it must be contained
  in a macro, in which case it will be evoked each time the macro runs.

  It is important to understand the time of execution of PCALC will effect its
  output. For instance, if =STAR.PCALC.NOW is entered before a star account
  appears in the STAR file and a reference to that star account occurs in the
  PCALC instruction set, an error will occur, due to the non-existence of the
  star account at that time.

  =STAR.PCALC.INI    <starting PCALC program address>

  This will begin PCALC processing as soon as the header section of STAR
  is complete, which is immediately after the starting main balance is read.

  =STAR.PCALC.EOS    <starting PCALC program address>

  This will begin PCALC processing as soon as the marker "$EOS" is read.

  =STAR.PCALC.END    <starting PCALC program address>

  This will begin PCALC processing as soon as the marker "$END" is read.

  =STAR.PCALC        <starting PCALC program address>

  This will begin PCALC processing as soon as the input file is read.

  =STAR.PCALC.CLOSE    <starting PCALC program address>

  This will begin PCALC processing as soon as the output file is closed.
  No STAR-based commands are allowed at this point.

  =STAR.PCALC.DSP    <display limit>

  This will control the output of PCALC that is directed towards the
  PCALC logical file name "star.pcalc.out". If the number of output lines is
  greater than <display limit>, the output lines will appear in the STAR
  section with the flags "=STAR.PCALC...". If number is less, the output
  lines will appear immediately before the listing of "! star accounts='..."
  Each output line of PCALC that is directed towards "star.pcalc.out" will
  appear as a line of text in the STAR output file preceeded by the
  flag "=STAR.PCALC.OUT". This collection of lines constitutes the
  virtual file "star.pcalc.out" as referenced in the PCALC modules. The
  default setting for <display limit> is 0.

  Closely related to the programming language PCALC described above,
  is the directive

  =STAR.CALC <expression>

  This will pass <expression> to the numeric processor CALC for evaluation.
  As all numerical inputs for STAR operations pass thru CALC if they are not
  simply a number, the effect of =STAR.CALC would be to help in the
  evaluation of those calculations. This directive is stored before the
  =STAR.PCALC directives and normally run before they do. All CALC variables
  defined using =STAR.CALC are global and as such can be accessed from any
  PCALC module.

  How to do an audit:

  On a regular basis you should audit the STAR file with the bank
  statement. Here's how its done:

  1. Process the file if any new data has been added since the last time
  it was processed. Save a copy for your records, if desired.

  2. Either add a leading '%" to or delete outstanding activity that now
  appears on the bank statement.

  3. Add in any extra items such as fees and interest in the audit section
  (before $EOS).

  4. Process the file and then review the audit balance to make sure it
  matches the bank's statement balance.

  5. Replace the old file with the new one.

  After entering new activity, you must process the file before deleting
  any data. If you wish to see updated balances, you must also process
  the file. Note the included files STAR.INP and STAR.OUT. STAR.OUT is the result
  of processing STAR.INP. The bank thinks there is $22.60 left in the account,
  the actual balance being $2.27 with a negative main balance (due to the
  overspending of the TAXI star account). The ATM debit has now been
  acknowledged by the bank, so it has a leading '%'.

  How to manage a budget:

  Once you have setup your banking STAR file, containing all your recurring
  bills, you can now estimate how much you have to spend on all other items
  that are paid directly from the main balance, such as food and restaurants.
  We will call these expenses "direct expenses". Make a copy of your
  banking file and enter your last paycheck. After processing this file with
  the "/v" (verbose) switch, note the increase in the main balance. If you
  make any changes to the file for direct expenses, process the file twice,
  entering your paycheck each time. This increase should be annualized and
  then divided by the number of budget cycles. Usually there are 12 budget
  cycles in a year. Call this annualized increase divided by the number of
  budget cycles the "direct budget". The direct budget should equal sum of all
  targets for direct expense budget accounts. After estimating the targets for
  all known direct expenses, create a budget account called "&misc" and let
  that have as its target the difference between the direct budget and the sum
  of the targets of all other direct expenses.

  If you incur external direct expenses or payments, enter them after $END
  with an appropriate budget name. This would be activity that does not
  effect the balances of this STAR file, but effects the balances of other
  STAR files. For external direct expenses, this name could be an existing
  name or a new one, depending on the nature of the expense. However, for
  external direct payments, which serve to minimize the budget shortfall,
  there should be given a budget name not associated with any expenses. It is
  important to do this as otherwise the positive influx into the budget will
  cause the estimator "&etgt" to under-estimate the eventual amount spent for
  that budget. In the external STAR file in which the expenses or payments
  were incurred, be careful to list the expenses under the appropriate
  budget name.

  The record entered for external amounts will not effect your main or audit
  balances, but it will effect the estimator "&etgt", which becomes negative
  if you overspend your direct expense budgets or positive if you underspend.

  The estimator "&dpay" is also useful for evaluating how you are doing with
  your direct expense budgets. It can tell you whether you have more or less
  relative to your direct expense targets, if set up using the total budget,
  adjusted for the length of time between paychecks. See the directive
  =STAR.DEFLATED.PAY.

  For instance, suppose your paycheck is $150.00 after indirect expenses, you
  are paid once every two weeks and your budget cycle is monthly. Your total
  budget would be 150*26/12 = $325. If you normally pay $200 for food and
  $100 for restaurants (those being the targets), then the budget "&misc" would
  have as its target 325-300 = $25. If you overspent by $50 in the month and
  made that up from an external source "B1", you would enter below $END:

  %B1 -50 &misc - received $50 in another account "yymmdd"

  assuming expenses in this STAR file are entered as positive numbers. This
  also could be accomplished using an internal transaction, as discussed
  above.

  This can be verified automatically with a PCALC module. For example,
  suppose there is a single budget account "misc" whose target is the budget.
  Assume there are 26 paychecks a year and 12 budget cycles. Then
  execute the following statement each time the paycheck is deposited and
  after all deductions have been made (using macros):

  @+DEPOSIT_PAY       =STAR.PCALC   <file>\check_misc

  where "check_misc" is as follows:

       module check_misc
       i=nint(pc_star(&misc.target)*100)
       j=nint((pc_star(#)-pc_star(#prev))*2600/12)
       if(gt(j,i)) then
           print "&misc should be increased by pc_calc((j-i)/100,f10.2)"
       else if(lt(j,i)) then
           print "&misc should be decreased by pc_calc((j-i)/100,f10.2)"
       endif
       end

  Notes:

  To cancel an outstanding item (leading '.'), enter in the unaudited section
  +VOID <entry amount>, process the file then delete both the +VOID line and
  the original item. If you simply delete an outstanding item, that will only
  effect the audit balance, not the balance.

  You can use STAR to roll-up multiple charges to a single number,
  such as rolling credit card charges to a single star account in the main
  file. In fact, any common set of expenses can be aggregated in the following
  manner. Simply create a separate STAR-formatted file. Then enter each charge
  as a star account entry, depending on how you wish to classify it. You can
  use multiple star account names to further classify the charges, or just one
  name. The amount that is to be transferred from this file is the main
  account, which changes each time the file is processed. This main account
  must be also be entered before the $EOS line in the output file, so as to
  allow the main account to consist solely of the next set of entries to be
  processed. The sum of the star accounts in this file should match the single
  number in the main file.
