INTRODUCTION



     The trick to this is that Atari PILOT uses the "@B" operator to
indicate a memory reference. When used on the left side of the equals
sign in a C: (compute) statement, it implies a store (just as does POKE
in BASIC). When used on the right side of an equals sign (or, for that
matter, in Jump tests, etc.), it implies a memory fetch (just as does
PEEK in BASIC).
     If you have already examined the BASIC code, you will probably
note a marked similarity between it and this PILOT example. Again,
we must take the larger number apart into its two components: the
number of units of 256 each (#H/256) and the remainder. Notice that
with PILOT we do not need to (nor can we) specify "INT(#H/256)".
There is no INT function simply because all arithmetic in Atari PILOT
is done with double-byte integers already. Sometimes, as in this
instance, that can be an advantage. Other times, the lack of floating
point will preclude PILOT being used for several applications.
     Notice the last line of the solution to problem 1: the use of the "\"
(modulo) operator is essentially just a convenient shorthand available
in several languages. In PILOT,

     "#H\256"

is exactly equivalent to

     "#H - (256 * (#H/256) )".

Atari PILOT is much more flexible and usable than the original, so
why not take advantage of all its features? Experiment. You will be glad
you did

Assembly And Machine Language
I almost didn't include this section, since anyone working with
assembly language (and especially those trying to debug at the
machine language level) would presumably know how to manipulate
bytes and words. And yet, it might prove interesting to those who do
not know assembler to see just how the 6502 processor really does
perform its feats.
     For the purposes of the example solutions, we will presume that
somewhere in our program we have coded something equivalent to the
following:
     V * = * + 1  ; reserve one byte for V
     H * = * + 2  ; reserve two bytes for H

Those lines do not give values to V and H; they simply assign
memory space to hold the eventual values (somewhat like
DIMensioning an array in Atari BASIC, which does not put any
particular values into the array). If we wished not only to reserve space
for the "variables" V and H but also to assign an initial value to them,
we could code this instead: