kickc/src/main/java/dk/camelot64/kickc/test/ref/fibmem.log

byte[15] fibs = $1100;

main();

void main() {
    fibs[0] = 0;
    fibs[1] = 1;
    byte i = 0;
    do {
        fibs[i+2] = fibs[i]+fibs[i+1];
    } while(++i<15)
}
Adding pre/post-modifier (byte) main::i ← ++ (byte) main::i
PROGRAM
  (byte[15]) fibs ← (word) 4352
  (void~) $0 ← call main 
proc (void()) main()
  *((byte[15]) fibs + (byte) 0) ← (byte) 0
  *((byte[15]) fibs + (byte) 1) ← (byte) 1
  (byte) main::i ← (byte) 0
main::@1:
  (byte~) main::$0 ← (byte) main::i + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs *idx (byte) main::i
  (byte~) main::$2 ← (byte) main::i + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i ← ++ (byte) main::i
  (boolean~) main::$5 ← (byte) main::i < (byte) 15
  if((boolean~) main::$5) goto main::@1
main::@return:
  return 
endproc // main()

SYMBOLS
(void~) $0
(byte[15]) fibs
(void()) main()
(byte~) main::$0
(byte~) main::$1
(byte~) main::$2
(byte~) main::$3
(byte~) main::$4
(boolean~) main::$5
(label) main::@1
(label) main::@return
(byte) main::i

INITIAL CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs ← (word) 4352
  (void~) $0 ← call main 
  to:@1
main: scope:[main]  from
  *((byte[15]) fibs + (byte) 0) ← (byte) 0
  *((byte[15]) fibs + (byte) 1) ← (byte) 1
  (byte) main::i ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte~) main::$0 ← (byte) main::i + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs *idx (byte) main::i
  (byte~) main::$2 ← (byte) main::i + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i ← ++ (byte) main::i
  (boolean~) main::$5 ← (byte) main::i < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@2
main::@2: scope:[main]  from main::@1
  to:main::@return
main::@return: scope:[main]  from main::@2
  return 
  to:@return
@1: scope:[]  from @begin
  to:@end
@end: scope:[]  from @1

Removing empty block main::@2
Removing empty block @1
CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs ← (word) 4352
  (void~) $0 ← call main 
  to:@end
main: scope:[main]  from
  *((byte[15]) fibs + (byte) 0) ← (byte) 0
  *((byte[15]) fibs + (byte) 1) ← (byte) 1
  (byte) main::i ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte~) main::$0 ← (byte) main::i + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs *idx (byte) main::i
  (byte~) main::$2 ← (byte) main::i + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i ← ++ (byte) main::i
  (boolean~) main::$5 ← (byte) main::i < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

PROCEDURE MODIFY VARIABLE ANALYSIS

CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
@begin: scope:[]  from
  (byte[15]) fibs ← (word) 4352
  call main param-assignment
  to:@2
@2: scope:[]  from @begin
  to:@end
main: scope:[main]  from @begin
  *((byte[15]) fibs + (byte) 0) ← (byte) 0
  *((byte[15]) fibs + (byte) 1) ← (byte) 1
  (byte) main::i ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte~) main::$0 ← (byte) main::i + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs *idx (byte) main::i
  (byte~) main::$2 ← (byte) main::i + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i ← ++ (byte) main::i
  (boolean~) main::$5 ← (byte) main::i < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @2

Completing Phi functions...
CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@2
@2: scope:[]  from @begin
  to:@end
main: scope:[main]  from @begin
  (byte[15]) fibs#1 ← phi( @begin/(byte[15]) fibs#0 )
  *((byte[15]) fibs#1 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#1 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#1 main::@1/(byte[15]) fibs#2 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  (boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @2

CONTROL FLOW GRAPH WITH ASSIGNMENT CALL & RETURN
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@2
@2: scope:[]  from @begin
  to:@end
main: scope:[main]  from @begin
  (byte[15]) fibs#1 ← phi( @begin/(byte[15]) fibs#0 )
  *((byte[15]) fibs#1 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#1 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#1 main::@1/(byte[15]) fibs#2 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  (boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @2

INITIAL SSA SYMBOL TABLE
(label) @2
(label) @begin
(label) @end
(byte[15]) fibs
(byte[15]) fibs#0
(byte[15]) fibs#1
(byte[15]) fibs#2
(void()) main()
(byte~) main::$0
(byte~) main::$1
(byte~) main::$2
(byte~) main::$3
(byte~) main::$4
(boolean~) main::$5
(label) main::@1
(label) main::@return
(byte) main::i
(byte) main::i#0
(byte) main::i#1
(byte) main::i#2

Culled Empty Block (label) @2
Succesful SSA optimization Pass2CullEmptyBlocks
CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  (byte[15]) fibs#1 ← phi( @begin/(byte[15]) fibs#0 )
  *((byte[15]) fibs#1 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#1 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#1 main::@1/(byte[15]) fibs#2 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  (boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Alias (byte[15]) fibs#0 = (byte[15]) fibs#1 
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 main::@1/(byte[15]) fibs#2 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  (boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Self Phi Eliminated (byte[15]) fibs#2
Succesful SSA optimization Pass2SelfPhiElimination
CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  (boolean~) main::$5 ← (byte) main::i#1 < (byte) 15
  if((boolean~) main::$5) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Simple Condition (boolean~) main::$5 if((byte) main::i#1<(byte) 15) goto main::@1
Succesful SSA optimization Pass2ConditionalJumpSimplification
CONTROL FLOW GRAPH
@begin: scope:[]  from
  (byte[15]) fibs#0 ← (word) 4352
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((byte[15]) fibs#0 + (byte) 0) ← (byte) 0
  *((byte[15]) fibs#0 + (byte) 1) ← (byte) 1
  (byte) main::i#0 ← (byte) 0
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(byte[15]) fibs#0 )
  (byte) main::i#2 ← phi( main/(byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Constant (const byte[15]) fibs#0 = 4352
Constant (const byte) main::i#0 = 0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[]  from
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0 + (byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0 + (byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte[15]) fibs#2 ← phi( main/(const byte[15]) fibs#0 )
  (byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Constant (const byte[15]) fibs#2 = fibs#0
Succesful SSA optimization Pass2ConstantIdentification
CONTROL FLOW GRAPH
@begin: scope:[]  from
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0 + (byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0 + (byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2 + (byte) 2
  (byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2 + (byte) 1
  (byte~) main::$3 ← (const byte[15]) fibs#2 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((const byte[15]) fibs#2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Consolidated assigned array index constant in assignment *(fibs#0+0)
Consolidated assigned array index constant in assignment *(fibs#0+1)
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Consolidated referenced array index constant in assignment main::$3
Consolidated assigned array index constant in assignment *(fibs#2+2 + main::$0)
Succesful SSA optimization Pass2ConstantAdditionElimination
CONTROL FLOW GRAPH
@begin: scope:[]  from
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$0 ← (byte) main::i#2
  (byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$2 ← (byte) main::i#2
  (byte~) main::$3 ← (const byte[15]) fibs#2+(byte) 1 *idx (byte~) main::$2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((const byte[15]) fibs#2+(byte) 2 + (byte~) main::$0) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Alias (byte) main::i#2 = (byte~) main::$0 (byte~) main::$2 
Succesful SSA optimization Pass2AliasElimination
CONTROL FLOW GRAPH
@begin: scope:[]  from
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte) main::i#2 ← phi( main/(const byte) main::i#0 main::@1/(byte) main::i#1 )
  (byte~) main::$1 ← (const byte[15]) fibs#2 *idx (byte) main::i#2
  (byte~) main::$3 ← (const byte[15]) fibs#2+(byte) 1 *idx (byte) main::i#2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((const byte[15]) fibs#2+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
Constant inlined fibs#2 = (const byte[15]) fibs#0
Constant inlined main::i#0 = (byte) 0
Succesful SSA optimization Pass2ConstantInlining
CONTROL FLOW GRAPH
@begin: scope:[]  from
  call main param-assignment
  to:@end
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@1
  (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 )
  (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2
  (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@1
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
@end: scope:[]  from @begin

FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[15]) fibs
(const byte[15]) fibs#0 = (word) 4352
(void()) main()
(byte~) main::$1
(byte~) main::$3
(byte~) main::$4
(label) main::@1
(label) main::@return
(byte) main::i
(byte) main::i#1
(byte) main::i#2

Block Sequence Planned @begin @end main main::@1 main::@return 
Added new block during phi lifting main::@3(between main::@1 and main::@1)
Block Sequence Planned @begin @end main main::@1 main::@return main::@3 
CONTROL FLOW GRAPH - PHI LIFTED
@begin: scope:[]  from
  call main param-assignment
  to:@end
@end: scope:[]  from @begin
main: scope:[main]  from @begin
  *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0
  *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1
  to:main::@1
main::@1: scope:[main]  from main main::@3
  (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte~) main::i#3 )
  (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2
  (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2
  (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3
  *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4
  (byte) main::i#1 ← ++ (byte) main::i#2
  if((byte) main::i#1<(byte) 15) goto main::@3
  to:main::@return
main::@return: scope:[main]  from main::@1
  return 
  to:@return
main::@3: scope:[main]  from main::@1
  (byte~) main::i#3 ← (byte) main::i#1
  to:main::@1

CALL GRAPH
Calls in [] to 0:main 

Propagating live ranges...
Propagating live ranges...
Propagating live ranges...
CONTROL FLOW GRAPH - LIVE RANGES FOUND
@begin: scope:[]  from
  [0] call main param-assignment [ ]
  to:@end
@end: scope:[]  from @begin
main: scope:[main]  from @begin
  [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ]
  [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ]
  to:main::@1
main::@1: scope:[main]  from main main::@3
  [3] (byte) main::i#2 ← phi( main/(byte) 0 main::@3/(byte~) main::i#3 ) [ main::i#2 ]
  [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
  [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
  [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ]
  [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
  [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
  [9] if((byte) main::i#1<(byte) 15) goto main::@3 [ main::i#1 ]
  to:main::@return
main::@return: scope:[main]  from main::@1
  [10] return  [ ]
  to:@return
main::@3: scope:[main]  from main::@1
  [11] (byte~) main::i#3 ← (byte) main::i#1 [ main::i#3 ]
  to:main::@1

Created 1 initial phi equivalence classes
Coalesced [11] main::i#3 ← main::i#1
Coalesced down to 1 phi equivalence classes
Culled Empty Block (label) main::@3
Block Sequence Planned @begin @end main main::@1 main::@return 
Propagating live ranges...
Propagating live ranges...
Propagating live ranges...
CONTROL FLOW GRAPH - PHI MEM COALESCED
@begin: scope:[]  from
  [0] call main param-assignment [ ]
  to:@end
@end: scope:[]  from @begin
main: scope:[main]  from @begin
  [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ]
  [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ]
  to:main::@1
main::@1: scope:[main]  from main main::@1
  [3] (byte) main::i#2 ← phi( main/(byte) 0 main::@1/(byte) main::i#1 ) [ main::i#2 ]
  [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ]
  [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
  [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ]
  [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ]
  [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
  [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ]
  to:main::@return
main::@return: scope:[main]  from main::@1
  [10] return  [ ]
  to:@return

DOMINATORS
@begin dominated by  @begin 
@end dominated by  @end @begin 
main dominated by  @begin main 
main::@1 dominated by  @begin main::@1 main 
main::@return dominated by  main::@return @begin main::@1 main 

Found back edge: Loop head: main::@1 tails: main::@1 blocks: null
Populated: Loop head: main::@1 tails: main::@1 blocks: main::@1 
NATURAL LOOPS
Loop head: main::@1 tails: main::@1 blocks: main::@1 

Found 0 loops in scope []
Found 1 loops in scope [main]
  Loop head: main::@1 tails: main::@1 blocks: main::@1 
NATURAL LOOPS WITH DEPTH
Loop head: main::@1 tails: main::@1 blocks: main::@1  depth: 1


VARIABLE REGISTER WEIGHTS
(byte[15]) fibs
(void()) main()
(byte~) main::$1 11.0
(byte~) main::$3 22.0
(byte~) main::$4 22.0
(byte) main::i
(byte) main::i#1 16.5
(byte) main::i#2 11.0

Initial phi equivalence classes
[ main::i#2 main::i#1 ]
Added variable main::$1 to zero page equivalence class [ main::$1 ]
Added variable main::$3 to zero page equivalence class [ main::$3 ]
Added variable main::$4 to zero page equivalence class [ main::$4 ]
Complete equivalence classes
[ main::i#2 main::i#1 ]
[ main::$1 ]
[ main::$3 ]
[ main::$4 ]
Allocated zp ZP_BYTE:2 [ main::i#2 main::i#1 ]
Allocated zp ZP_BYTE:3 [ main::$1 ]
Allocated zp ZP_BYTE:4 [ main::$3 ]
Allocated zp ZP_BYTE:5 [ main::$4 ]
INITIAL ASM
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
  jsr main
  jmp bend
//SEG3 @end
bend:
//SEG4 main
main: {
    .label _1 = 3
    .label _3 = 4
    .label _4 = 5
    .label i = 2
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  b1_from_main:
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- zpby1=coby1 
    lda #$0
    sta i
    jmp b1
  //SEG9 [3] phi from main::@1 to main::@1
  b1_from_b1:
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
    jmp b1
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- zpby1=cowo1_staridx_zpby2 
    ldx i
    lda fibs,x
    sta _1
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ] -- zpby1=cowo1_staridx_zpby2 
    ldx i
    lda fibs+$1,x
    sta _3
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- zpby1=zpby2_plus_zpby3 
    lda _1
    clc
    adc _3
    sta _4
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_zpby1=zpby2 
    lda _4
    ldx i
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1 
    inc i
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- zpby1_lt_coby1_then_la1 
    lda i
    cmp #$f
    bcc b1_from_b1
    jmp breturn
  //SEG18 main::@return
  breturn:
  //SEG19 [10] return  [ ]
    rts
}

Statement [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] always clobbers reg byte a 
Statement [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] always clobbers reg byte a 
Statement [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] always clobbers reg byte a 
Statement [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] always clobbers reg byte a 
Equivalence Class zp ZP_BYTE:4 [ main::$3 ] has ALU potential.
REGISTER UPLIFT POTENTIAL REGISTERS
Potential registers zp ZP_BYTE:2 [ main::i#2 main::i#1 ] : zp ZP_BYTE:2 , reg byte a , reg byte x , reg byte y , 
Potential registers zp ZP_BYTE:3 [ main::$1 ] : zp ZP_BYTE:3 , reg byte a , reg byte x , reg byte y , 
Potential registers zp ZP_BYTE:4 [ main::$3 ] : zp ZP_BYTE:4 , reg byte a , reg byte x , reg byte y , reg byte alu , 
Potential registers zp ZP_BYTE:5 [ main::$4 ] : zp ZP_BYTE:5 , reg byte a , reg byte x , reg byte y , 

REGISTER UPLIFT SCOPES
Uplift Scope [main] 27.5: zp ZP_BYTE:2 [ main::i#2 main::i#1 ] 22: zp ZP_BYTE:4 [ main::$3 ] 22: zp ZP_BYTE:5 [ main::$4 ] 11: zp ZP_BYTE:3 [ main::$1 ] 
Uplift Scope [] 

Uplifting [main] best 362 combination reg byte x [ main::i#2 main::i#1 ] reg byte alu [ main::$3 ] reg byte a [ main::$4 ] reg byte a [ main::$1 ] 
Uplifting [] best 362 combination 
MISSING FRAGMENTS
  zpby1=zpby2_plus_cowo1_staridx_zpby3
  zpby1=zpby2_plus_cowo1_staridx_aby
  zpby1=zpby2_plus_cowo1_staridx_xby
  zpby1=zpby2_plus_cowo1_staridx_yby
  aby=zpby1_plus_cowo1_staridx_zpby2
  aby=zpby1_plus_cowo1_staridx_xby
  aby=zpby1_plus_cowo1_staridx_yby
  xby=zpby1_plus_cowo1_staridx_zpby2
  xby=zpby1_plus_cowo1_staridx_aby
  xby=zpby1_plus_cowo1_staridx_yby
  yby=zpby1_plus_cowo1_staridx_zpby2
  yby=zpby1_plus_cowo1_staridx_aby
  yby=zpby1_plus_cowo1_staridx_xby
  zpby1=aby_plus_cowo1_staridx_zpby2
  aby=aby_plus_cowo1_staridx_zpby1
  xby=aby_plus_cowo1_staridx_zpby1
  yby=aby_plus_cowo1_staridx_zpby1
  zpby1=xby_plus_cowo1_staridx_zpby2
  zpby1=xby_plus_cowo1_staridx_aby
  zpby1=xby_plus_cowo1_staridx_yby
  aby=xby_plus_cowo1_staridx_zpby1
  aby=xby_plus_cowo1_staridx_yby
  xby=xby_plus_cowo1_staridx_zpby1
  xby=xby_plus_cowo1_staridx_aby
  xby=xby_plus_cowo1_staridx_yby
  yby=xby_plus_cowo1_staridx_zpby1
  yby=xby_plus_cowo1_staridx_aby
  zpby1=yby_plus_cowo1_staridx_zpby2
  zpby1=yby_plus_cowo1_staridx_aby
  zpby1=yby_plus_cowo1_staridx_xby
  aby=yby_plus_cowo1_staridx_zpby1
  aby=yby_plus_cowo1_staridx_xby
  xby=yby_plus_cowo1_staridx_zpby1
  xby=yby_plus_cowo1_staridx_aby
  yby=yby_plus_cowo1_staridx_zpby1
  yby=yby_plus_cowo1_staridx_aby
  yby=yby_plus_cowo1_staridx_xby
Removing instruction jmp bend
Removing instruction jmp b1
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
  jsr main
//SEG3 @end
bend:
//SEG4 main
main: {
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  b1_from_main:
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
    ldx #$0
    jmp b1
  //SEG9 [3] phi from main::@1 to main::@1
  b1_from_b1:
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
    lda fibs,x
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
    // [5] main::$3 ← fibs#0+1 *idx main::i#2  //  ALU
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
    clc
    adc fibs+$1,x
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
    inx
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
    cpx #$f
    bcc b1_from_b1
  //SEG18 main::@return
  breturn:
  //SEG19 [10] return  [ ]
    rts
}

Replacing label b1_from_b1 with b1
Removing instruction b1_from_b1:
Succesful ASM optimization Pass5RedundantLabelElimination
ASSEMBLER
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
bbegin:
//SEG2 [0] call main param-assignment [ ]
  jsr main
//SEG3 @end
bend:
//SEG4 main
main: {
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  b1_from_main:
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
    ldx #$0
    jmp b1
  //SEG9 [3] phi from main::@1 to main::@1
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
    lda fibs,x
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
    // [5] main::$3 ← fibs#0+1 *idx main::i#2  //  ALU
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
    clc
    adc fibs+$1,x
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
    inx
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
    cpx #$f
    bcc b1
  //SEG18 main::@return
  breturn:
  //SEG19 [10] return  [ ]
    rts
}

Removing instruction bbegin:
Removing instruction bend:
Removing instruction b1_from_main:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
ASSEMBLER
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
  jsr main
//SEG3 @end
//SEG4 main
main: {
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
    ldx #$0
    jmp b1
  //SEG9 [3] phi from main::@1 to main::@1
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
    lda fibs,x
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
    // [5] main::$3 ← fibs#0+1 *idx main::i#2  //  ALU
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
    clc
    adc fibs+$1,x
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
    inx
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
    cpx #$f
    bcc b1
  //SEG18 main::@return
  //SEG19 [10] return  [ ]
    rts
}

Removing instruction jmp b1
Succesful ASM optimization Pass5NextJumpElimination
ASSEMBLER
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
  jsr main
//SEG3 @end
//SEG4 main
main: {
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
    ldx #$0
  //SEG9 [3] phi from main::@1 to main::@1
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
    lda fibs,x
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
    // [5] main::$3 ← fibs#0+1 *idx main::i#2  //  ALU
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
    clc
    adc fibs+$1,x
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
    inx
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
    cpx #$f
    bcc b1
  //SEG18 main::@return
  //SEG19 [10] return  [ ]
    rts
}

FINAL SYMBOL TABLE
(label) @begin
(label) @end
(byte[15]) fibs
(const byte[15]) fibs#0 = (word) 4352
(void()) main()
(byte~) main::$1 reg byte a 11.0
(byte~) main::$3 reg byte alu 22.0
(byte~) main::$4 reg byte a 22.0
(label) main::@1
(label) main::@return
(byte) main::i
(byte) main::i#1 reg byte x 16.5
(byte) main::i#2 reg byte x 11.0

reg byte x [ main::i#2 main::i#1 ]
reg byte a [ main::$1 ]
reg byte alu [ main::$3 ]
reg byte a [ main::$4 ]

FINAL CODE
//SEG0 Global Constants & labels
  .const fibs = $1100
//SEG1 @begin
//SEG2 [0] call main param-assignment [ ]
  jsr main
//SEG3 @end
//SEG4 main
main: {
  //SEG5 [1] *((const byte[15]) fibs#0+(byte) 0) ← (byte) 0 [ ] -- _star_cowo1=coby2 
    lda #$0
    sta fibs+$0
  //SEG6 [2] *((const byte[15]) fibs#0+(byte) 1) ← (byte) 1 [ ] -- _star_cowo1=coby2 
    lda #$1
    sta fibs+$1
  //SEG7 [3] phi from main to main::@1
  //SEG8 [3] phi (byte) main::i#2 = (byte) 0 -- xby=coby1 
    ldx #$0
  //SEG9 [3] phi from main::@1 to main::@1
  //SEG10 [3] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy 
  //SEG11 main::@1
  b1:
  //SEG12 [4] (byte~) main::$1 ← (const byte[15]) fibs#0 *idx (byte) main::i#2 [ main::i#2 main::$1 ] -- aby=cowo1_staridx_xby 
    lda fibs,x
  //SEG13 [5] (byte~) main::$3 ← (const byte[15]) fibs#0+(byte) 1 *idx (byte) main::i#2 [ main::i#2 main::$1 main::$3 ]
    // [5] main::$3 ← fibs#0+1 *idx main::i#2  //  ALU
  //SEG14 [6] (byte~) main::$4 ← (byte~) main::$1 + (byte~) main::$3 [ main::i#2 main::$4 ] -- aby=aby_plus_cowo1_staridx_xby 
    clc
    adc fibs+$1,x
  //SEG15 [7] *((const byte[15]) fibs#0+(byte) 2 + (byte) main::i#2) ← (byte~) main::$4 [ main::i#2 ] -- cowo1_staridx_xby=aby 
    sta fibs+$2,x
  //SEG16 [8] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby 
    inx
  //SEG17 [9] if((byte) main::i#1<(byte) 15) goto main::@1 [ main::i#1 ] -- xby_lt_coby1_then_la1 
    cpx #$f
    bcc b1
  //SEG18 main::@return
  //SEG19 [10] return  [ ]
    rts
}