LDA                  LDA Load accumulator with memory                 LDA

  Operation:  M -> A                                    N V - B D I Z C
                                                        / . . . . . / .

  +----------------+-----------------------+---------+---------+----------+
  | Addressing Mode| Assembly Language Form| OP CODE |No. Bytes|No. Cycles|
  +----------------+-----------------------+---------+---------+----------+
  |  Immediate     |   LDA #$FF            |   $A9   |    2    |    2     |
  |  ZeroPage      |   LDA $FF             |   $A5   |    2    |    3     |
  |  ZeroPage,X    |   LDA $FF,X           |   $B5   |    2    |    4     |
  |  Absolute      |   LDA $FFFF           |   $AD   |    3    |    4     |
  |  Absolute,X    |   LDA $FFFF,X         |   $BD   |    3    |    4*    |
  |  Absolute,Y    |   LDA $FFFF,Y         |   $B9   |    3    |    4*    |
  |  (Indirect,X)  |   LDA ($FF,X)         |   $A1   |    2    |    6     |
  |  (Indirect),Y  |   LDA ($FF),Y         |   $B1   |    2    |    5*    |
  +----------------+-----------------------+---------+---------+----------+
  * Add 1 if page boundary is crossed.
  For penalty cycles on the 65816, check the desired addressing mode.

 65816 Extensions:

  +----------------+-----------------------+---------+---------+----------+
  | Addressing Mode| Assembly Language Form| OP CODE |No. Bytes|No. Cycles|
  +----------------+-----------------------+---------+---------+----------+
  | AbsoluteLong   |   LDA $FFFFFF         |   $AF   |    4    |     5    |
  | AbsoluteLong,X |   LDA $FFFFFF,X       |   $BF   |    4    |     5    |
  | (Indirect)     |   LDA ($FF)           |   $B2   |    2    |     5    |
  | [Indirect Long]|   LDA [$FF]           |   $A7   |    2    |     6    |
  | [Ind.Long],Y   |   LDA [$FF],Y         |   $B7   |    2    |     6    |
  | Relative,S     |   LDA $FF,S           |   $A3   |    2    |     4    |
  | (Indirect,S),Y |   LDA ($FF,S),Y       |   $B3   |    2    |     7    |
  +----------------+-----------------------+---------+---------+----------+

What it does: Loads the Accumulator with a byte from memory. Copy might be a better word than load, since the byte in memory is unaffected by the transfer.

Major uses: The busiest place in the computer. Bytes coming in from disk, tape, or keyboard all flow through the Accumulator, as do bytes on their way to screen or peripherals. Also, because the Accumulator differs in some important ways from the X and Y Registers, the Accumulator is used by ML programmers in a different way from the other registers.

Since INY/DEY and INX/DEX make those registers useful as counters for loops (the Accumulator couldn't be conveniently employed as an index; there is no INA instruction), the Accumulator is the main temporary storage register for bytes during their manipulation in an ML program. ML programming, in fact, can be defined as essentially the rapid, organized maneuvering of single bytes in memory. And it is the Accumulator where these bytes often briefly rest before being sent elsewhere.