Fixing pointer addition (word*~) main::$4 ← (word*~) main::$3 + (number) 1
Fixing pointer addition (signed word*~) main::$6 ← (signed word*~) main::$5 + (number) 2
Fixing pointer addition (word*~) main::$11 ← (word*~) main::$10 + (number) 1
Fixing pointer addition (signed word*~) main::$13 ← (signed word*~) main::$12 + (number) 2
Fixing pointer addition (word*~) main::$18 ← (word*~) main::$17 + (number) 1
Fixing pointer addition (signed word*~) main::$20 ← (signed word*~) main::$19 + (number) 2
Fixing pointer addition (word*~) main::$25 ← (word*~) main::$24 + (number) 1
Fixing pointer addition (signed word*~) main::$27 ← (signed word*~) main::$26 + (number) 2
Identified constant variable (byte*) ub_screen
Identified constant variable (signed byte*) sb_screen
Identified constant variable (word*) uw_screen
Identified constant variable (signed word*) sw_screen
Identified constant variable (byte) ub
Identified constant variable (signed byte) sb
Identified constant variable (word) uw
Identified constant variable (signed word) sw

CONTROL FLOW GRAPH SSA
@begin: scope:[]  from
  (byte*) ub_screen#0 ← ((byte*)) (number) $400
  (signed byte*) sb_screen#0 ← ((signed byte*)) (number) $428
  (word*) uw_screen#0 ← ((word*)) (number) $450
  (signed word*) sw_screen#0 ← ((signed word*)) (number) $478
  (byte) ub#0 ← (number) $29
  (signed byte) sb#0 ← (number) -$29
  (word) uw#0 ← (number) $3000
  (signed word) sw#0 ← (number) -$3000
  to:@1
main: scope:[main]  from @1
  (byte*~) main::$0 ← ((byte*)) (byte*) ub_screen#0
  *((byte*~) main::$0) ← (byte) ub#0
  (signed byte*~) main::$1 ← ((signed byte*)) (byte*) ub_screen#0
  (signed byte*~) main::$2 ← (signed byte*~) main::$1 + (number) 1
  *((signed byte*~) main::$2) ← (signed byte) sb#0
  (word*~) main::$3 ← ((word*)) (byte*) ub_screen#0
  (number~) main::$28 ← (number) 1 * (const byte) SIZEOF_WORD
  (word*~) main::$4 ← (word*~) main::$3 + (number~) main::$28
  *((word*~) main::$4) ← (word) uw#0
  (signed word*~) main::$5 ← ((signed word*)) (byte*) ub_screen#0
  (number~) main::$29 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word*~) main::$6 ← (signed word*~) main::$5 + (number~) main::$29
  *((signed word*~) main::$6) ← (signed word) sw#0
  (byte*~) main::$7 ← ((byte*)) (signed byte*) sb_screen#0
  *((byte*~) main::$7) ← (byte) ub#0
  (signed byte*~) main::$8 ← ((signed byte*)) (signed byte*) sb_screen#0
  (signed byte*~) main::$9 ← (signed byte*~) main::$8 + (number) 1
  *((signed byte*~) main::$9) ← (signed byte) sb#0
  (word*~) main::$10 ← ((word*)) (signed byte*) sb_screen#0
  (number~) main::$30 ← (number) 1 * (const byte) SIZEOF_WORD
  (word*~) main::$11 ← (word*~) main::$10 + (number~) main::$30
  *((word*~) main::$11) ← (word) uw#0
  (signed word*~) main::$12 ← ((signed word*)) (signed byte*) sb_screen#0
  (number~) main::$31 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word*~) main::$13 ← (signed word*~) main::$12 + (number~) main::$31
  *((signed word*~) main::$13) ← (signed word) sw#0
  (byte*~) main::$14 ← ((byte*)) (word*) uw_screen#0
  *((byte*~) main::$14) ← (byte) ub#0
  (signed byte*~) main::$15 ← ((signed byte*)) (word*) uw_screen#0
  (signed byte*~) main::$16 ← (signed byte*~) main::$15 + (number) 1
  *((signed byte*~) main::$16) ← (signed byte) sb#0
  (word*~) main::$17 ← ((word*)) (word*) uw_screen#0
  (number~) main::$32 ← (number) 1 * (const byte) SIZEOF_WORD
  (word*~) main::$18 ← (word*~) main::$17 + (number~) main::$32
  *((word*~) main::$18) ← (word) uw#0
  (signed word*~) main::$19 ← ((signed word*)) (word*) uw_screen#0
  (number~) main::$33 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word*~) main::$20 ← (signed word*~) main::$19 + (number~) main::$33
  *((signed word*~) main::$20) ← (signed word) sw#0
  (byte*~) main::$21 ← ((byte*)) (signed word*) sw_screen#0
  *((byte*~) main::$21) ← (byte) ub#0
  (signed byte*~) main::$22 ← ((signed byte*)) (signed word*) sw_screen#0
  (signed byte*~) main::$23 ← (signed byte*~) main::$22 + (number) 1
  *((signed byte*~) main::$23) ← (signed byte) sb#0
  (word*~) main::$24 ← ((word*)) (signed word*) sw_screen#0
  (number~) main::$34 ← (number) 1 * (const byte) SIZEOF_WORD
  (word*~) main::$25 ← (word*~) main::$24 + (number~) main::$34
  *((word*~) main::$25) ← (word) uw#0
  (signed word*~) main::$26 ← ((signed word*)) (signed word*) sw_screen#0
  (number~) main::$35 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
  (signed word*~) main::$27 ← (signed word*~) main::$26 + (number~) main::$35
  *((signed word*~) main::$27) ← (signed word) sw#0
  to:main::@return
main::@return: scope:[main]  from main
  return 
  to:@return
@1: scope:[]  from @begin
  call main 
  to:@2
@2: scope:[]  from @1
  to:@end
@end: scope:[]  from @2

SYMBOL TABLE SSA
(label) @1
(label) @2
(label) @begin
(label) @end
(const byte) SIZEOF_SIGNED_WORD = (byte) 2
(const byte) SIZEOF_WORD = (byte) 2
(void()) main()
(byte*~) main::$0
(signed byte*~) main::$1
(word*~) main::$10
(word*~) main::$11
(signed word*~) main::$12
(signed word*~) main::$13
(byte*~) main::$14
(signed byte*~) main::$15
(signed byte*~) main::$16
(word*~) main::$17
(word*~) main::$18
(signed word*~) main::$19
(signed byte*~) main::$2
(signed word*~) main::$20
(byte*~) main::$21
(signed byte*~) main::$22
(signed byte*~) main::$23
(word*~) main::$24
(word*~) main::$25
(signed word*~) main::$26
(signed word*~) main::$27
(number~) main::$28
(number~) main::$29
(word*~) main::$3
(number~) main::$30
(number~) main::$31
(number~) main::$32
(number~) main::$33
(number~) main::$34
(number~) main::$35
(word*~) main::$4
(signed word*~) main::$5
(signed word*~) main::$6
(byte*~) main::$7
(signed byte*~) main::$8
(signed byte*~) main::$9
(label) main::@return
(signed byte) sb
(signed byte) sb#0
(signed byte*) sb_screen
(signed byte*) sb_screen#0
(signed word) sw
(signed word) sw#0
(signed word*) sw_screen
(signed word*) sw_screen#0
(byte) ub
(byte) ub#0
(byte*) ub_screen
(byte*) ub_screen#0
(word) uw
(word) uw#0
(word*) uw_screen
(word*) uw_screen#0

Adding number conversion cast (unumber) $29 in (byte) ub#0 ← (number) $29
Adding number conversion cast (snumber) -$29 in (signed byte) sb#0 ← (number) -$29
Adding number conversion cast (unumber) $3000 in (word) uw#0 ← (number) $3000
Adding number conversion cast (snumber) -$3000 in (signed word) sw#0 ← (number) -$3000
Adding number conversion cast (unumber) 1 in (signed byte*~) main::$2 ← (signed byte*~) main::$1 + (number) 1
Adding number conversion cast (unumber) 1 in (number~) main::$28 ← (number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$28 in (number~) main::$28 ← (unumber)(number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) 2 in (number~) main::$29 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) main::$29 in (number~) main::$29 ← (unumber)(number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) 1 in (signed byte*~) main::$9 ← (signed byte*~) main::$8 + (number) 1
Adding number conversion cast (unumber) 1 in (number~) main::$30 ← (number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$30 in (number~) main::$30 ← (unumber)(number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) 2 in (number~) main::$31 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) main::$31 in (number~) main::$31 ← (unumber)(number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) 1 in (signed byte*~) main::$16 ← (signed byte*~) main::$15 + (number) 1
Adding number conversion cast (unumber) 1 in (number~) main::$32 ← (number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$32 in (number~) main::$32 ← (unumber)(number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) 2 in (number~) main::$33 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) main::$33 in (number~) main::$33 ← (unumber)(number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) 1 in (signed byte*~) main::$23 ← (signed byte*~) main::$22 + (number) 1
Adding number conversion cast (unumber) 1 in (number~) main::$34 ← (number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) main::$34 in (number~) main::$34 ← (unumber)(number) 1 * (const byte) SIZEOF_WORD
Adding number conversion cast (unumber) 2 in (number~) main::$35 ← (number) 2 * (const byte) SIZEOF_SIGNED_WORD
Adding number conversion cast (unumber) main::$35 in (number~) main::$35 ← (unumber)(number) 2 * (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization PassNAddNumberTypeConversions
Inlining cast (byte*) ub_screen#0 ← (byte*)(number) $400
Inlining cast (signed byte*) sb_screen#0 ← (signed byte*)(number) $428
Inlining cast (word*) uw_screen#0 ← (word*)(number) $450
Inlining cast (signed word*) sw_screen#0 ← (signed word*)(number) $478
Inlining cast (byte) ub#0 ← (unumber)(number) $29
Inlining cast (signed byte) sb#0 ← (snumber)(number) -$29
Inlining cast (word) uw#0 ← (unumber)(number) $3000
Inlining cast (signed word) sw#0 ← (snumber)(number) -$3000
Inlining cast (byte*~) main::$0 ← (byte*)(byte*) ub_screen#0
Inlining cast (signed byte*~) main::$1 ← (signed byte*)(byte*) ub_screen#0
Inlining cast (word*~) main::$3 ← (word*)(byte*) ub_screen#0
Inlining cast (signed word*~) main::$5 ← (signed word*)(byte*) ub_screen#0
Inlining cast (byte*~) main::$7 ← (byte*)(signed byte*) sb_screen#0
Inlining cast (signed byte*~) main::$8 ← (signed byte*)(signed byte*) sb_screen#0
Inlining cast (word*~) main::$10 ← (word*)(signed byte*) sb_screen#0
Inlining cast (signed word*~) main::$12 ← (signed word*)(signed byte*) sb_screen#0
Inlining cast (byte*~) main::$14 ← (byte*)(word*) uw_screen#0
Inlining cast (signed byte*~) main::$15 ← (signed byte*)(word*) uw_screen#0
Inlining cast (word*~) main::$17 ← (word*)(word*) uw_screen#0
Inlining cast (signed word*~) main::$19 ← (signed word*)(word*) uw_screen#0
Inlining cast (byte*~) main::$21 ← (byte*)(signed word*) sw_screen#0
Inlining cast (signed byte*~) main::$22 ← (signed byte*)(signed word*) sw_screen#0
Inlining cast (word*~) main::$24 ← (word*)(signed word*) sw_screen#0
Inlining cast (signed word*~) main::$26 ← (signed word*)(signed word*) sw_screen#0
Successful SSA optimization Pass2InlineCast
Simplifying constant pointer cast (byte*) 1024
Simplifying constant pointer cast (signed byte*) 1064
Simplifying constant pointer cast (word*) 1104
Simplifying constant pointer cast (signed word*) 1144
Simplifying constant integer cast $29
Simplifying constant integer cast -$29
Simplifying constant integer cast $3000
Simplifying constant integer cast -$3000
Simplifying constant integer cast (byte*) ub_screen#0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 2
Simplifying constant integer cast (signed byte*) sb_screen#0
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast 2
Simplifying constant integer cast 1
Simplifying constant integer cast (word*) uw_screen#0
Simplifying constant integer cast 1
Simplifying constant integer cast 2
Simplifying constant integer cast 1
Simplifying constant integer cast 1
Simplifying constant integer cast (signed word*) sw_screen#0
Simplifying constant integer cast 2
Successful SSA optimization PassNCastSimplification
Finalized unsigned number type (byte) $29
Finalized signed number type (signed byte) -$29
Finalized unsigned number type (word) $3000
Finalized signed number type (signed word) -$3000
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 2
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 2
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 2
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 1
Finalized unsigned number type (byte) 2
Successful SSA optimization PassNFinalizeNumberTypeConversions
Inferred type updated to byte in (unumber~) main::$28 ← (byte) 1 * (const byte) SIZEOF_WORD
Inferred type updated to byte in (unumber~) main::$29 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Inferred type updated to byte in (unumber~) main::$30 ← (byte) 1 * (const byte) SIZEOF_WORD
Inferred type updated to byte in (unumber~) main::$31 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Inferred type updated to byte in (unumber~) main::$32 ← (byte) 1 * (const byte) SIZEOF_WORD
Inferred type updated to byte in (unumber~) main::$33 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Inferred type updated to byte in (unumber~) main::$34 ← (byte) 1 * (const byte) SIZEOF_WORD
Inferred type updated to byte in (unumber~) main::$35 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [14] (byte~) main::$28 ← (byte) 1 * (const byte) SIZEOF_WORD
Constant right-side identified [18] (byte~) main::$29 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [27] (byte~) main::$30 ← (byte) 1 * (const byte) SIZEOF_WORD
Constant right-side identified [31] (byte~) main::$31 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [40] (byte~) main::$32 ← (byte) 1 * (const byte) SIZEOF_WORD
Constant right-side identified [44] (byte~) main::$33 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Constant right-side identified [53] (byte~) main::$34 ← (byte) 1 * (const byte) SIZEOF_WORD
Constant right-side identified [57] (byte~) main::$35 ← (byte) 2 * (const byte) SIZEOF_SIGNED_WORD
Successful SSA optimization Pass2ConstantRValueConsolidation
Constant (const byte*) ub_screen#0 = (byte*) 1024
Constant (const signed byte*) sb_screen#0 = (signed byte*) 1064
Constant (const word*) uw_screen#0 = (word*) 1104
Constant (const signed word*) sw_screen#0 = (signed word*) 1144
Constant (const byte) ub#0 = $29
Constant (const signed byte) sb#0 = -$29
Constant (const word) uw#0 = $3000
Constant (const signed word) sw#0 = -$3000
Constant (const byte) main::$28 = 1*SIZEOF_WORD
Constant (const byte) main::$29 = 2*SIZEOF_SIGNED_WORD
Constant (const byte) main::$30 = 1*SIZEOF_WORD
Constant (const byte) main::$31 = 2*SIZEOF_SIGNED_WORD
Constant (const byte) main::$32 = 1*SIZEOF_WORD
Constant (const byte) main::$33 = 2*SIZEOF_SIGNED_WORD
Constant (const byte) main::$34 = 1*SIZEOF_WORD
Constant (const byte) main::$35 = 2*SIZEOF_SIGNED_WORD
Successful SSA optimization Pass2ConstantIdentification
Constant (const byte*) main::$0 = ub_screen#0
Constant (const signed byte*) main::$8 = sb_screen#0
Constant (const word*) main::$17 = uw_screen#0
Constant (const signed word*) main::$26 = sw_screen#0
Successful SSA optimization Pass2ConstantIdentification
Constant value identified (signed byte*)ub_screen#0 in [10] (signed byte*~) main::$1 ← (signed byte*)(const byte*) ub_screen#0
Constant value identified (word*)ub_screen#0 in [13] (word*~) main::$3 ← (word*)(const byte*) ub_screen#0
Constant value identified (signed word*)ub_screen#0 in [17] (signed word*~) main::$5 ← (signed word*)(const byte*) ub_screen#0
Constant value identified (byte*)sb_screen#0 in [21] (byte*~) main::$7 ← (byte*)(const signed byte*) sb_screen#0
Constant value identified (word*)sb_screen#0 in [26] (word*~) main::$10 ← (word*)(const signed byte*) sb_screen#0
Constant value identified (signed word*)sb_screen#0 in [30] (signed word*~) main::$12 ← (signed word*)(const signed byte*) sb_screen#0
Constant value identified (byte*)uw_screen#0 in [34] (byte*~) main::$14 ← (byte*)(const word*) uw_screen#0
Constant value identified (signed byte*)uw_screen#0 in [36] (signed byte*~) main::$15 ← (signed byte*)(const word*) uw_screen#0
Constant value identified (signed word*)uw_screen#0 in [43] (signed word*~) main::$19 ← (signed word*)(const word*) uw_screen#0
Constant value identified (byte*)sw_screen#0 in [47] (byte*~) main::$21 ← (byte*)(const signed word*) sw_screen#0
Constant value identified (signed byte*)sw_screen#0 in [49] (signed byte*~) main::$22 ← (signed byte*)(const signed word*) sw_screen#0
Constant value identified (word*)sw_screen#0 in [52] (word*~) main::$24 ← (word*)(const signed word*) sw_screen#0
Successful SSA optimization Pass2ConstantValues
Converting *(pointer+n) to pointer[n] [12] *((signed byte*~) main::$2) ← (const signed byte) sb#0  -- *(main::$1 + 1)
Converting *(pointer+n) to pointer[n] [16] *((word*~) main::$4) ← (const word) uw#0  -- *(main::$3 + main::$28)
Converting *(pointer+n) to pointer[n] [20] *((signed word*~) main::$6) ← (const signed word) sw#0  -- *(main::$5 + main::$29)
Converting *(pointer+n) to pointer[n] [25] *((signed byte*~) main::$9) ← (const signed byte) sb#0  -- *(main::$8 + 1)
Converting *(pointer+n) to pointer[n] [29] *((word*~) main::$11) ← (const word) uw#0  -- *(main::$10 + main::$30)
Converting *(pointer+n) to pointer[n] [33] *((signed word*~) main::$13) ← (const signed word) sw#0  -- *(main::$12 + main::$31)
Converting *(pointer+n) to pointer[n] [38] *((signed byte*~) main::$16) ← (const signed byte) sb#0  -- *(main::$15 + 1)
Converting *(pointer+n) to pointer[n] [42] *((word*~) main::$18) ← (const word) uw#0  -- *(main::$17 + main::$32)
Converting *(pointer+n) to pointer[n] [46] *((signed word*~) main::$20) ← (const signed word) sw#0  -- *(main::$19 + main::$33)
Converting *(pointer+n) to pointer[n] [51] *((signed byte*~) main::$23) ← (const signed byte) sb#0  -- *(main::$22 + 1)
Converting *(pointer+n) to pointer[n] [55] *((word*~) main::$25) ← (const word) uw#0  -- *(main::$24 + main::$34)
Converting *(pointer+n) to pointer[n] [59] *((signed word*~) main::$27) ← (const signed word) sw#0  -- *(main::$26 + main::$35)
Successful SSA optimization Pass2InlineDerefIdx
Eliminating unused variable (signed byte*~) main::$2 and assignment [2] (signed byte*~) main::$2 ← (signed byte*~) main::$1 + (byte) 1
Eliminating unused variable (word*~) main::$4 and assignment [5] (word*~) main::$4 ← (word*~) main::$3 + (const byte) main::$28
Eliminating unused variable (signed word*~) main::$6 and assignment [8] (signed word*~) main::$6 ← (signed word*~) main::$5 + (const byte) main::$29
Eliminating unused variable (signed byte*~) main::$9 and assignment [12] (signed byte*~) main::$9 ← (const signed byte*) main::$8 + (byte) 1
Eliminating unused variable (word*~) main::$11 and assignment [15] (word*~) main::$11 ← (word*~) main::$10 + (const byte) main::$30
Eliminating unused variable (signed word*~) main::$13 and assignment [18] (signed word*~) main::$13 ← (signed word*~) main::$12 + (const byte) main::$31
Eliminating unused variable (signed byte*~) main::$16 and assignment [23] (signed byte*~) main::$16 ← (signed byte*~) main::$15 + (byte) 1
Eliminating unused variable (word*~) main::$18 and assignment [25] (word*~) main::$18 ← (const word*) main::$17 + (const byte) main::$32
Eliminating unused variable (signed word*~) main::$20 and assignment [28] (signed word*~) main::$20 ← (signed word*~) main::$19 + (const byte) main::$33
Eliminating unused variable (signed byte*~) main::$23 and assignment [33] (signed byte*~) main::$23 ← (signed byte*~) main::$22 + (byte) 1
Eliminating unused variable (word*~) main::$25 and assignment [36] (word*~) main::$25 ← (word*~) main::$24 + (const byte) main::$34
Eliminating unused variable (signed word*~) main::$27 and assignment [38] (signed word*~) main::$27 ← (const signed word*) main::$26 + (const byte) main::$35
Successful SSA optimization PassNEliminateUnusedVars
Constant (const signed byte*) main::$1 = (signed byte*)ub_screen#0
Constant (const word*) main::$3 = (word*)ub_screen#0
Constant (const signed word*) main::$5 = (signed word*)ub_screen#0
Constant (const byte*) main::$7 = (byte*)sb_screen#0
Constant (const word*) main::$10 = (word*)sb_screen#0
Constant (const signed word*) main::$12 = (signed word*)sb_screen#0
Constant (const byte*) main::$14 = (byte*)uw_screen#0
Constant (const signed byte*) main::$15 = (signed byte*)uw_screen#0
Constant (const signed word*) main::$19 = (signed word*)uw_screen#0
Constant (const byte*) main::$21 = (byte*)sw_screen#0
Constant (const signed byte*) main::$22 = (signed byte*)sw_screen#0
Constant (const word*) main::$24 = (word*)sw_screen#0
Successful SSA optimization Pass2ConstantIdentification
Constant inlined main::$34 = (byte) 1*(const byte) SIZEOF_WORD
Constant inlined main::$12 = (signed word*)(const signed byte*) sb_screen#0
Constant inlined main::$35 = (byte) 2*(const byte) SIZEOF_SIGNED_WORD
Constant inlined main::$24 = (word*)(const signed word*) sw_screen#0
Constant inlined main::$14 = (byte*)(const word*) uw_screen#0
Constant inlined main::$26 = (const signed word*) sw_screen#0
Constant inlined main::$15 = (signed byte*)(const word*) uw_screen#0
Constant inlined main::$30 = (byte) 1*(const byte) SIZEOF_WORD
Constant inlined main::$31 = (byte) 2*(const byte) SIZEOF_SIGNED_WORD
Constant inlined main::$32 = (byte) 1*(const byte) SIZEOF_WORD
Constant inlined main::$10 = (word*)(const signed byte*) sb_screen#0
Constant inlined main::$21 = (byte*)(const signed word*) sw_screen#0
Constant inlined main::$33 = (byte) 2*(const byte) SIZEOF_SIGNED_WORD
Constant inlined main::$22 = (signed byte*)(const signed word*) sw_screen#0
Constant inlined main::$1 = (signed byte*)(const byte*) ub_screen#0
Constant inlined main::$17 = (const word*) uw_screen#0
Constant inlined main::$28 = (byte) 1*(const byte) SIZEOF_WORD
Constant inlined main::$29 = (byte) 2*(const byte) SIZEOF_SIGNED_WORD
Constant inlined main::$0 = (const byte*) ub_screen#0
Constant inlined main::$19 = (signed word*)(const word*) uw_screen#0
Constant inlined main::$5 = (signed word*)(const byte*) ub_screen#0
Constant inlined main::$3 = (word*)(const byte*) ub_screen#0
Constant inlined main::$7 = (byte*)(const signed byte*) sb_screen#0
Constant inlined main::$8 = (const signed byte*) sb_screen#0
Successful SSA optimization Pass2ConstantInlining
Consolidated array index constant in *((signed byte*)ub_screen#0+1)
Consolidated array index constant in *((word*)ub_screen#0+1*SIZEOF_WORD)
Consolidated array index constant in *((signed word*)ub_screen#0+2*SIZEOF_SIGNED_WORD)
Consolidated array index constant in *(sb_screen#0+1)
Consolidated array index constant in *((word*)sb_screen#0+1*SIZEOF_WORD)
Consolidated array index constant in *((signed word*)sb_screen#0+2*SIZEOF_SIGNED_WORD)
Consolidated array index constant in *((signed byte*)uw_screen#0+1)
Consolidated array index constant in *(uw_screen#0+1*SIZEOF_WORD)
Consolidated array index constant in *((signed word*)uw_screen#0+2*SIZEOF_SIGNED_WORD)
Consolidated array index constant in *((signed byte*)sw_screen#0+1)
Consolidated array index constant in *((word*)sw_screen#0+1*SIZEOF_WORD)
Consolidated array index constant in *(sw_screen#0+2*SIZEOF_SIGNED_WORD)
Successful SSA optimization Pass2ConstantAdditionElimination
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @2
Adding NOP phi() at start of @end
CALL GRAPH
Calls in [] to main:2 

Created 0 initial phi equivalence classes
Coalesced down to 0 phi equivalence classes
Culled Empty Block (label) @2
Adding NOP phi() at start of @begin
Adding NOP phi() at start of @1
Adding NOP phi() at start of @end

FINAL CONTROL FLOW GRAPH
@begin: scope:[]  from
  [0] phi()
  to:@1
@1: scope:[]  from @begin
  [1] phi()
  [2] call main 
  to:@end
@end: scope:[]  from @1
  [3] phi()
main: scope:[main]  from @1
  [4] *((const byte*) ub_screen#0) ← (const byte) ub#0
  [5] *((signed byte*)(const byte*) ub_screen#0+(byte) 1) ← (const signed byte) sb#0
  [6] *((word*)(const byte*) ub_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0
  [7] *((signed word*)(const byte*) ub_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0
  [8] *((byte*)(const signed byte*) sb_screen#0) ← (const byte) ub#0
  [9] *((const signed byte*) sb_screen#0+(byte) 1) ← (const signed byte) sb#0
  [10] *((word*)(const signed byte*) sb_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0
  [11] *((signed word*)(const signed byte*) sb_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0
  [12] *((byte*)(const word*) uw_screen#0) ← (const byte) ub#0
  [13] *((signed byte*)(const word*) uw_screen#0+(byte) 1) ← (const signed byte) sb#0
  [14] *((const word*) uw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0
  [15] *((signed word*)(const word*) uw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0
  [16] *((byte*)(const signed word*) sw_screen#0) ← (const byte) ub#0
  [17] *((signed byte*)(const signed word*) sw_screen#0+(byte) 1) ← (const signed byte) sb#0
  [18] *((word*)(const signed word*) sw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0
  [19] *((const signed word*) sw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0
  to:main::@return
main::@return: scope:[main]  from main
  [20] return 
  to:@return


VARIABLE REGISTER WEIGHTS
(void()) main()
(signed byte) sb
(signed byte*) sb_screen
(signed word) sw
(signed word*) sw_screen
(byte) ub
(byte*) ub_screen
(word) uw
(word*) uw_screen

Initial phi equivalence classes
Complete equivalence classes

INITIAL ASM
Target platform is c64basic
  // File Comments
// Tests casting pointer types to other pointer types
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  .const SIZEOF_SIGNED_WORD = 2
  .label ub_screen = $400
  .label sb_screen = $428
  .label uw_screen = $450
  .label sw_screen = $478
  .const ub = $29
  .const sb = -$29
  .const uw = $3000
  .const sw = -$3000
  // @begin
bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
b1_from_bbegin:
  jmp b1
  // @1
b1:
  // [2] call main 
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
bend_from_b1:
  jmp bend
  // @end
bend:
  // main
main: {
    // [4] *((const byte*) ub_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta ub_screen
    // [5] *((signed byte*)(const byte*) ub_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta ub_screen+1
    // [6] *((word*)(const byte*) ub_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta ub_screen+1*SIZEOF_WORD
    lda #>uw
    sta ub_screen+1*SIZEOF_WORD+1
    // [7] *((signed word*)(const byte*) ub_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD+1
    // [8] *((byte*)(const signed byte*) sb_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sb_screen
    // [9] *((const signed byte*) sb_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sb_screen+1
    // [10] *((word*)(const signed byte*) sb_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sb_screen+1*SIZEOF_WORD
    lda #>uw
    sta sb_screen+1*SIZEOF_WORD+1
    // [11] *((signed word*)(const signed byte*) sb_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD+1
    // [12] *((byte*)(const word*) uw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta uw_screen
    // [13] *((signed byte*)(const word*) uw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta uw_screen+1
    // [14] *((const word*) uw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta uw_screen+1*SIZEOF_WORD
    lda #>uw
    sta uw_screen+1*SIZEOF_WORD+1
    // [15] *((signed word*)(const word*) uw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD+1
    // [16] *((byte*)(const signed word*) sw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sw_screen
    // [17] *((signed byte*)(const signed word*) sw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sw_screen+1
    // [18] *((word*)(const signed word*) sw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sw_screen+1*SIZEOF_WORD
    lda #>uw
    sta sw_screen+1*SIZEOF_WORD+1
    // [19] *((const signed word*) sw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD+1
    jmp breturn
    // main::@return
  breturn:
    // [20] return 
    rts
}
  // File Data

REGISTER UPLIFT POTENTIAL REGISTERS
Statement [4] *((const byte*) ub_screen#0) ← (const byte) ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [5] *((signed byte*)(const byte*) ub_screen#0+(byte) 1) ← (const signed byte) sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [6] *((word*)(const byte*) ub_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [7] *((signed word*)(const byte*) ub_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [8] *((byte*)(const signed byte*) sb_screen#0) ← (const byte) ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [9] *((const signed byte*) sb_screen#0+(byte) 1) ← (const signed byte) sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [10] *((word*)(const signed byte*) sb_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [11] *((signed word*)(const signed byte*) sb_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [12] *((byte*)(const word*) uw_screen#0) ← (const byte) ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [13] *((signed byte*)(const word*) uw_screen#0+(byte) 1) ← (const signed byte) sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [14] *((const word*) uw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [15] *((signed word*)(const word*) uw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [16] *((byte*)(const signed word*) sw_screen#0) ← (const byte) ub#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [17] *((signed byte*)(const signed word*) sw_screen#0+(byte) 1) ← (const signed byte) sb#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [18] *((word*)(const signed word*) sw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 
Statement [19] *((const signed word*) sw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 [ ] ( main:2 [ ] ) always clobbers reg byte a 

REGISTER UPLIFT SCOPES
Uplift Scope [main] 
Uplift Scope [] 

Uplifting [main] best 165 combination 
Uplifting [] best 165 combination 

ASSEMBLER BEFORE OPTIMIZATION
  // File Comments
// Tests casting pointer types to other pointer types
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(bbegin)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  .const SIZEOF_SIGNED_WORD = 2
  .label ub_screen = $400
  .label sb_screen = $428
  .label uw_screen = $450
  .label sw_screen = $478
  .const ub = $29
  .const sb = -$29
  .const uw = $3000
  .const sw = -$3000
  // @begin
bbegin:
  // [1] phi from @begin to @1 [phi:@begin->@1]
b1_from_bbegin:
  jmp b1
  // @1
b1:
  // [2] call main 
  jsr main
  // [3] phi from @1 to @end [phi:@1->@end]
bend_from_b1:
  jmp bend
  // @end
bend:
  // main
main: {
    // [4] *((const byte*) ub_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta ub_screen
    // [5] *((signed byte*)(const byte*) ub_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta ub_screen+1
    // [6] *((word*)(const byte*) ub_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta ub_screen+1*SIZEOF_WORD
    lda #>uw
    sta ub_screen+1*SIZEOF_WORD+1
    // [7] *((signed word*)(const byte*) ub_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD+1
    // [8] *((byte*)(const signed byte*) sb_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sb_screen
    // [9] *((const signed byte*) sb_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sb_screen+1
    // [10] *((word*)(const signed byte*) sb_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sb_screen+1*SIZEOF_WORD
    lda #>uw
    sta sb_screen+1*SIZEOF_WORD+1
    // [11] *((signed word*)(const signed byte*) sb_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD+1
    // [12] *((byte*)(const word*) uw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta uw_screen
    // [13] *((signed byte*)(const word*) uw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta uw_screen+1
    // [14] *((const word*) uw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta uw_screen+1*SIZEOF_WORD
    lda #>uw
    sta uw_screen+1*SIZEOF_WORD+1
    // [15] *((signed word*)(const word*) uw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD+1
    // [16] *((byte*)(const signed word*) sw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sw_screen
    // [17] *((signed byte*)(const signed word*) sw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sw_screen+1
    // [18] *((word*)(const signed word*) sw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sw_screen+1*SIZEOF_WORD
    lda #>uw
    sta sw_screen+1*SIZEOF_WORD+1
    // [19] *((const signed word*) sw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD+1
    jmp breturn
    // main::@return
  breturn:
    // [20] return 
    rts
}
  // File Data

ASSEMBLER OPTIMIZATIONS
Removing instruction jmp b1
Removing instruction jmp bend
Removing instruction jmp breturn
Succesful ASM optimization Pass5NextJumpElimination
Removing instruction b1_from_bbegin:
Removing instruction b1:
Removing instruction bend_from_b1:
Succesful ASM optimization Pass5RedundantLabelElimination
Removing instruction bend:
Removing instruction breturn:
Succesful ASM optimization Pass5UnusedLabelElimination
Updating BasicUpstart to call main directly
Removing instruction jsr main
Succesful ASM optimization Pass5SkipBegin
Removing instruction bbegin:
Succesful ASM optimization Pass5UnusedLabelElimination

FINAL SYMBOL TABLE
(label) @1
(label) @begin
(label) @end
(const byte) SIZEOF_SIGNED_WORD SIZEOF_SIGNED_WORD = (byte) 2
(const byte) SIZEOF_WORD SIZEOF_WORD = (byte) 2
(void()) main()
(label) main::@return
(signed byte) sb
(const signed byte) sb#0 sb = (signed byte) -$29
(signed byte*) sb_screen
(const signed byte*) sb_screen#0 sb_screen = (signed byte*) 1064
(signed word) sw
(const signed word) sw#0 sw = (signed word) -$3000
(signed word*) sw_screen
(const signed word*) sw_screen#0 sw_screen = (signed word*) 1144
(byte) ub
(const byte) ub#0 ub = (byte) $29
(byte*) ub_screen
(const byte*) ub_screen#0 ub_screen = (byte*) 1024
(word) uw
(const word) uw#0 uw = (word) $3000
(word*) uw_screen
(const word*) uw_screen#0 uw_screen = (word*) 1104



FINAL ASSEMBLER
Score: 150

  // File Comments
// Tests casting pointer types to other pointer types
  // Upstart
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
  // Global Constants & labels
  .const SIZEOF_WORD = 2
  .const SIZEOF_SIGNED_WORD = 2
  .label ub_screen = $400
  .label sb_screen = $428
  .label uw_screen = $450
  .label sw_screen = $478
  .const ub = $29
  .const sb = -$29
  .const uw = $3000
  .const sw = -$3000
  // @begin
  // [1] phi from @begin to @1 [phi:@begin->@1]
  // @1
  // [2] call main 
  // [3] phi from @1 to @end [phi:@1->@end]
  // @end
  // main
main: {
    // *((byte*)ub_screen) = ub
    // [4] *((const byte*) ub_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta ub_screen
    // *((signed byte*)ub_screen+1) = sb
    // [5] *((signed byte*)(const byte*) ub_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta ub_screen+1
    // *((word*)ub_screen+1)= uw
    // [6] *((word*)(const byte*) ub_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta ub_screen+1*SIZEOF_WORD
    lda #>uw
    sta ub_screen+1*SIZEOF_WORD+1
    // *((signed word*)ub_screen+2) = sw
    // [7] *((signed word*)(const byte*) ub_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta ub_screen+2*SIZEOF_SIGNED_WORD+1
    // *((byte*)sb_screen) = ub
    // [8] *((byte*)(const signed byte*) sb_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sb_screen
    // *((signed byte*)sb_screen+1) = sb
    // [9] *((const signed byte*) sb_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sb_screen+1
    // *((word*)sb_screen+1)= uw
    // [10] *((word*)(const signed byte*) sb_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sb_screen+1*SIZEOF_WORD
    lda #>uw
    sta sb_screen+1*SIZEOF_WORD+1
    // *((signed word*)sb_screen+2) = sw
    // [11] *((signed word*)(const signed byte*) sb_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sb_screen+2*SIZEOF_SIGNED_WORD+1
    // *((byte*)uw_screen) = ub
    // [12] *((byte*)(const word*) uw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta uw_screen
    // *((signed byte*)uw_screen+1) = sb
    // [13] *((signed byte*)(const word*) uw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta uw_screen+1
    // *((word*)uw_screen+1)= uw
    // [14] *((const word*) uw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta uw_screen+1*SIZEOF_WORD
    lda #>uw
    sta uw_screen+1*SIZEOF_WORD+1
    // *((signed word*)uw_screen+2) = sw
    // [15] *((signed word*)(const word*) uw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta uw_screen+2*SIZEOF_SIGNED_WORD+1
    // *((byte*)sw_screen) = ub
    // [16] *((byte*)(const signed word*) sw_screen#0) ← (const byte) ub#0 -- _deref_pbuc1=vbuc2 
    lda #ub
    sta sw_screen
    // *((signed byte*)sw_screen+1) = sb
    // [17] *((signed byte*)(const signed word*) sw_screen#0+(byte) 1) ← (const signed byte) sb#0 -- _deref_pbsc1=vbsc2 
    lda #sb
    sta sw_screen+1
    // *((word*)sw_screen+1)= uw
    // [18] *((word*)(const signed word*) sw_screen#0+(byte) 1*(const byte) SIZEOF_WORD) ← (const word) uw#0 -- _deref_pwuc1=vwuc2 
    lda #<uw
    sta sw_screen+1*SIZEOF_WORD
    lda #>uw
    sta sw_screen+1*SIZEOF_WORD+1
    // *((signed word*)sw_screen+2) = sw
    // [19] *((const signed word*) sw_screen#0+(byte) 2*(const byte) SIZEOF_SIGNED_WORD) ← (const signed word) sw#0 -- _deref_pwsc1=vwsc2 
    lda #<sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD
    lda #>sw
    sta sw_screen+2*SIZEOF_SIGNED_WORD+1
    // main::@return
    // }
    // [20] return 
    rts
}
  // File Data

