si ca peut deja t'eviter d'en ecrire certaines, voila les regles indiquées dans Jwarn :
( à condition qu'elles soient vraies )

* RULE 1:
* An instruction reads a register containing the result o the previous
* instruction, one tick of wait is incurred until the previous
* operation completes.

* RULE 2:
* An instruction uses the flags from the prvious instruction, one tick
* of wait is incurred until the previous operation completes.

* RULE 3:
* An ALU result, memory load value or divide result has to be written
* back and neither instruction about to be executed matches, one tick
* of wait is incurred to let the data be written.

* RULE 4:
* Two values are to be written back at once, one tick of wait is
* incurred.

* RULE 5:
* An instr. attempts to use the result of a divide inst. before it's
* ready. Wait states are inserted until the divide unit completes the
* divide, between one and sixteen wait states can be incurred.
*
* RULE 6:
* A dividie instr. is about to be executed and the previous one has not
* completed, between one and sixteen wait states can be incurred.

* RULE 7:
* An instr. reads a register which is awaiting data from an incomplete
* memory read, this will be no more than one tick from internal memory,
* but several ticks from external memory.

* RULE 8:
* A load or store instr. is about tob be executed and the memory
* interface has not completed the transfer for the previous ones (one
* internal load/store or two external loads/stores can be pending
* without holding up instruction flow).

* RULE 9:
* After a store instr. with indexed addressing mode

* RULE 10:
* After a jump or jr (three ticks if executing out of internal memory).