
+++ start of data +++

+++ external: "primitive_wrap_machine_word" +++
+++ external: "primitive_wrap_c_pointer" +++
+++ external: "primitive_exit_application" +++

+++ variable{constant "Pstatic_root"} " in section untraced-data" = 0 +++

+++ variable{constant "Pimmut_root"} " in section untraced-data" = 0 +++

+++ variable{constant "Pambig_root"} " in section untraced-data" = 0 +++

+++ variable{constant "Pexact_root"} " in section untraced-data" = 0 +++

+++ (public) variable{constant "_module_hInstance"} " in section untraced-data" = 0 +++

+++ (public) variable{indirect-constant "_init_dylan_library"} " in section untraced-data" = 0 +++
+++ external: "primitive_ensure_valid_teb" +++
+++ external: "primitive_register_traced_roots" +++
+++ external: "primitive_deregister_traced_roots" +++
+++ external: "_dylan_init_thread_local" +++
+++ external: "primitive_call_first_dylan_iep" +++
+++ external: "_GetModuleHandleA@4" +++
+++ external: "primitive_fixup_imported_dylan_data" +++
+++ external: "primitive_fixup_unimported_dylan_data" +++

+++ Defining glue symbols +++
  Data start is "_dylan_data_start"
  Data end is "_dylan_data_end"
  Variables start is "_dylan_vars_start"
  Variables end is "_dylan_vars_end"
  Objects start is "_dylan_objs_start"
  Objects end is "_dylan_objs_end"
  Fixup start is "_dylan_fixup_start"
  Fixup end is "_dylan_fixup_end"
  Import start is "_dylan_import_start"
  Import end is "_dylan_import_end"


+++ start of code +++


+++ Defining function _init_dylan_data in section init-code +++

+++ Static function definition _init_dylan_data +++

+++ starting code for _init_dylan_data +++

#() [0->5] (level:0) is red with stack state before
#({basic-block #({tag 2:95}) 95 110})
  rem	"This is a dummy first basic block."

#({tag 2:95}) [95->110] (level:0) is #f with stack state #f
#({basic-block #() 5 20})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->20] (level:0) is red with stack state with
#({basic-block #() 20 35})
  push	{constant "_dylan_import_end"}
  move	eax, {constant "_dylan_import_start"}
  call	{constant "primitive_fixup_unimported_dylan_data"}, 1

#() [20->35] (level:0) is red with stack state with
#({basic-block #() 35 85})
  push	{constant "_dylan_fixup_end"}
  move	eax, {constant "_dylan_fixup_start"}
  call	{constant "primitive_fixup_imported_dylan_data"}, 1

#() [35->85] (level:0) is red with stack state with
#({basic-block #() 85 85})
  push	{constant "Pexact_root"}
  push	{constant "_dylan_vars_end"}
  push	{constant "_dylan_vars_start"}
  push	{constant "Pstatic_root"}
  push	{constant "_dylan_objs_end"}
  push	{constant "_dylan_objs_start"}
  push	{constant "Pambig_root"}
  push	{constant "_dylan_data_end"}
  move	eax, {constant "_dylan_data_start"}
  call	{constant "primitive_register_traced_roots"}, 1

#() [85->85] (level:0) is red with stack state with
#({basic-block #({tag 1:90}) 90 95})

#({tag 1:90}) [90->95] (level:0) is #f with stack state #f
#({basic-block #() 85 90})
  preserve-registers-exit	

#() [85->90] (level:0) is red with stack state #f
#()
  rts	

+++ ending code for _init_dylan_data +++

+++ Live variable scopes for _init_dylan_data +++
Start scope at 7 with frame for no variables
End scope at 86

+++ No Source Code Locators for _init_dylan_data +++


+++ Defining function _call_init_dylan in section init-code +++

+++ Static function definition _call_init_dylan +++

+++ starting code for _call_init_dylan +++

#() [0->5] (level:0) is red with stack state before
#({basic-block #({tag 2:20}) 20 35})
  rem	"This is a dummy first basic block."

#({tag 2:20}) [20->35] (level:0) is #f with stack state #f
#({basic-block #() 5 10})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->10] (level:0) is red with stack state with
#({basic-block #() 10 10})
  call	{indirect-constant "_init_dylan_library"}, 0

#() [10->10] (level:0) is red with stack state with
#({basic-block #({tag 1:15}) 15 20})

#({tag 1:15}) [15->20] (level:0) is #f with stack state #f
#({basic-block #() 10 15})
  preserve-registers-exit	

#() [10->15] (level:0) is red with stack state #f
#()
  rts	

+++ ending code for _call_init_dylan +++

+++ Live variable scopes for _call_init_dylan +++
Start scope at 7 with frame for no variables
End scope at 12

+++ No Source Code Locators for _call_init_dylan +++


+++ Defining function _dylan_initialize in section init-code +++

+++ Static function definition _dylan_initialize +++

+++ starting code for _dylan_initialize +++

#() [0->5] (level:0) is red with stack state before
#({basic-block #({tag 2:85}) 85 100})
  rem	"This is a dummy first basic block."

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 5 20})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->20] (level:0) is red with stack state with
#({basic-block #() 20 25})
  push	0
  move	N0/NSPILL-0, esp
  call-alien	{constant "_init_dylan_data"}, 0

#() [20->25] (level:0) is red with stack state with
#({basic-block #() 25 60})
  call	{constant "primitive_ensure_valid_teb"}, 0

#() [25->60] (level:0) is red with stack state with
#({basic-block #() 60 75})
  move	N1/edi, eax
  st	-1, N1/edi, 20
  push	0
  push	0
  push	{constant "_call_init_dylan"}
  push	N0/NSPILL-0
  call-alien	{constant "_dylan_init_thread_local"}, 0

#() [60->75] (level:0) is red with stack state with
#({basic-block #({tag 1:80}) 80 85})
  add	esp, esp, 16
  st	0, N1/edi, 20
  move	eax, 0

#({tag 1:80}) [80->85] (level:0) is #f with stack state #f
#({basic-block #() 75 80})
  preserve-registers-exit	

#() [75->80] (level:0) is red with stack state #f
#()
  rts	

+++ ending code for _dylan_initialize +++

+++ Frame sizes for _dylan_initialize: GC: 0, NC: 1 +++

+++ Live variable scopes for _dylan_initialize +++
Start scope at 7 with frame for no variables
End scope at 64

+++ No Source Code Locators for _dylan_initialize +++


+++ Defining function _dylan_main in section init-code +++

+++ starting code for _dylan_main +++

#() [0->5] (level:0) is red with stack state before
#({basic-block #({tag 2:65}) 65 80})
  rem	"This is a dummy first basic block."

#({tag 2:65}) [65->80] (level:0) is #f with stack state #f
#({basic-block #() 5 15})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->15] (level:0) is red with stack state with
#({basic-block #() 15 25})
  push	0
  call-alien	{constant "_GetModuleHandleA@4"}, 0

#() [15->25] (level:0) is red with stack state with
#({basic-block #() 25 45})
  st	eax, {constant "_module_hInstance"}, 0
  call-alien	{constant "_dylan_initialize"}, 0

#() [25->45] (level:0) is red with stack state with
#({basic-block #() 45 55})
  push	{constant "Pexact_root"}
  push	{constant "Pstatic_root"}
  move	eax, {constant "Pambig_root"}
  call	{constant "primitive_deregister_traced_roots"}, 1

#() [45->55] (level:0) is red with stack state with
#({basic-block #() 55 55})
  move	eax, eax
  call	{constant "primitive_exit_application"}, 1

#() [55->55] (level:0) is red with stack state with
#({basic-block #({tag 1:60}) 60 65})

#({tag 1:60}) [60->65] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  preserve-registers-exit	

#() [55->60] (level:0) is red with stack state #f
#()
  rts	

+++ ending code for _dylan_main +++

+++ Live variable scopes for _dylan_main +++
Start scope at 7 with frame for no variables
End scope at 51

+++ No Source Code Locators for _dylan_main +++


+++ starting code for primitive_runtime_module_handle +++

#() [0->5] (level:0) is red with stack state before
#({basic-block #({tag 2:30}) 30 45})
  rem	"This is a dummy first basic block."

#({tag 2:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 5 20})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->20] (level:0) is red with stack state with
#({basic-block #() 20 20})
  ld	N0/eax, {constant "_module_hInstance"}, 0
  move	eax, N0/eax
  call	{constant "primitive_wrap_machine_word"}, 1

#() [20->20] (level:0) is red with stack state with
#({basic-block #({tag 1:25}) 25 30})

#({tag 1:25}) [25->30] (level:0) is #f with stack state #f
#({basic-block #() 20 25})
  preserve-registers-exit	

#() [20->25] (level:0) is red with stack state #f
#()
  rts-and-drop	0

+++ ending code for primitive_runtime_module_handle +++

+++ Live variable scopes for primitive_runtime_module_handle +++
Start scope at 3 with frame for no variables
End scope at 13

+++ No Source Code Locators for primitive_runtime_module_handle +++


+++ Defining function _DylanDllEntry@12 in section init-code +++

+++ starting code for _DylanDllEntry@12 +++

#() [0->5] (level:0) is green with stack state before
#({basic-block #() 5 25})
  rem	"This is a dummy first basic block."

#() [5->25] (level:0) is green with stack state before
#({basic-block #() 25 30}, {basic-block #({tag 10:105}) 105 120})
  load-stack-arg-n	#f, N0/eax, 0
  load-stack-arg-n	#f, N1/edx, 1
  rem	"eliminated"
  beq	{tag 10:105}, 1, N1/edx

#() [25->30] (level:0) is green with stack state before
#({basic-block #() 30 35}, {basic-block #({tag 3:40}, {tag 2:40}, {tag 5:40}) 40 45})
  beq	{tag 2:40}, 2, N1/edx

#() [30->35] (level:0) is green with stack state before
#({basic-block #() 35 40}, {basic-block #({tag 3:40}, {tag 2:40}, {tag 5:40}) 40 45})
  beq	{tag 3:40}, 3, N1/edx

#() [35->40] (level:0) is green with stack state before
#({basic-block #({tag 3:40}, {tag 2:40}, {tag 5:40}) 40 45}, {basic-block #({tag 9:90}) 90 105})
  beq	{tag 9:90}, 0, N1/edx

#({tag 3:40}, {tag 2:40}, {tag 5:40}) [40->45] (level:0) is green with stack state before
#({basic-block #({tag 7:45}) 45 50})
  move	eax, -1

#({tag 7:45}) [45->50] (level:0) is green with stack state #f
#()
  rts-and-drop	12

#({tag 10:105}) [105->120] (level:0) is #f with stack state #f
#({basic-block #({tag 1:50}) 50 60})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 1:50}) [50->60] (level:0) is red with stack state with
#({basic-block #({tag 6:80}) 80 85})
  st	N0/eax, {constant "_module_hInstance"}, 0
  call-alien	{constant "_dylan_initialize"}, 0

#({tag 6:80}) [80->85] (level:0) is green with stack state with
#({basic-block #({tag 8:85}) 85 90})
  move	eax, -1

#({tag 8:85}) [85->90] (level:0) is #f with stack state #f
#({basic-block #({tag 7:45}) 45 50})
  preserve-registers-exit	

#() [120->125] (level:0) is #f with stack state #f
#()
  bra	{tag 7:45}

#({tag 9:90}) [90->105] (level:0) is #f with stack state #f
#({basic-block #({tag 4:60}) 60 80})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 4:60}) [60->80] (level:0) is red with stack state with
#({basic-block #({tag 6:80}) 80 85})
  push	{constant "Pexact_root"}
  push	{constant "Pstatic_root"}
  move	eax, {constant "Pambig_root"}
  call	{constant "primitive_deregister_traced_roots"}, 1

#() [125->130] (level:0) is #f with stack state #f
#()
  bra	{tag 6:80}

+++ ending code for _DylanDllEntry@12 +++

+++ Live variable scopes for _DylanDllEntry@12 +++
Start scope at 43 with frame for no variables
End scope at 59
Start scope at 60 no frame for no variables
End scope at 76

+++ No Source Code Locators for _DylanDllEntry@12 +++

