
+++ start of data +++

+++ external: "KPunboundVKi" +++
+++ external: "KPfalseVKi" +++
+++ external: "KPtrueVKi" +++
+++ external: "KPempty_listVKi" +++
+++ external: "KPempty_vectorVKi" +++
+++ external: "Ddirect_object_mm_wrappersVKi" +++
+++ external: "Ddirect_object_classesVKi" +++
+++ external: "KLtraceable_value_cellGVKiW" +++
+++ external: "KLuntraceable_value_cellGVKiW" +++
+++ external: "KLuntraceable_double_value_cellGVKiW" +++
+++ external: "KLmachine_wordGVKeW" +++
+++ external: "Tdispatch_profiling_enabledQTVKe" +++
+++ external: "Tclass_profiling_enabledQTVKe" +++
+++ external: "KLobjectGVKd" +++
+++ external: "KLobjectGVKdW" +++
+++ external: "KLsingle_floatGVKdW" +++
+++ external: "KLdouble_floatGVKdW" +++
+++ external: "KLsimple_object_vectorGVKdW" +++
+++ external: "KLbyte_stringGVKdW" +++
+++ external: "KLmethodGVKdW" +++
+++ external: "KerrorVKd" +++
+++ external: "Kargument_count_errorVKiI" +++
+++ external: "Kodd_keyword_arguments_errorVKiI" +++
+++ external: "Kunknown_keyword_argument_errorVKiI" +++
+++ external: "Ktype_check_errorVKiI" +++
+++ external: "Kstack_overflow_errorVKiI" +++
+++ external: "Kgrounded_instanceQVKeI" +++
+++ external: "dylan__malloc__misc" +++
+++ external: "dylan__malloc__ambig" +++
+++ external: "dylan__malloc__exact" +++
+++ external: "dylan__free__root" +++
+++ external: "mps__malloc" +++
+++ external: "mps__free" +++
+++ external: "primitive_mps_park" +++
+++ external: "primitive_mps_release" +++


+++ defining "Kprimitive_error_string" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 65
	BYTE "Primitive error."
	BYTE 0
+++ (public) variable{indirect-constant "Prunning_under_dylan_debuggerQ"} " in section untraced-data" = 0 +++
+++ external: "primitive_alloc" +++
+++ external: "primitive_alloc_s1" +++
+++ external: "primitive_alloc_s2" +++
+++ external: "primitive_alloc_s" +++
+++ external: "primitive_alloc_r" +++
+++ external: "primitive_alloc_rf" +++
+++ external: "primitive_alloc_rt" +++
+++ external: "primitive_alloc_s_r" +++
+++ external: "primitive_alloc_s_rb" +++
+++ external: "primitive_alloc_leaf" +++
+++ external: "primitive_alloc_leaf_s_r" +++
+++ external: "primitive_alloc_leaf_s1" +++
+++ external: "primitive_alloc_leaf_s2" +++
+++ external: "primitive_alloc_leaf_s" +++
+++ external: "primitive_alloc_leaf_r" +++
+++ external: "primitive_alloc_leaf_s_rbf" +++
+++ external: "primitive_alloc_leaf_s_rbfz" +++
+++ external: "primitive_alloc_leaf_rbfz" +++
+++ external: "primitive_alloc_leaf_s_rb" +++
+++ external: "primitive_alloc_exact_awl_s_r" +++
+++ external: "primitive_alloc_exact_awl_rf" +++
+++ external: "primitive_alloc_weak_awl_s_r" +++
+++ external: "primitive_alloc_weak_awl_rf" +++
+++ external: "primitive_alloc_wrapper_s_r" +++
+++ external: "primitive_copy" +++
+++ external: "primitive_copy_r" +++
+++ external: "primitive_wrap_machine_word" +++
+++ external: "primitive_wrap_c_pointer" +++


+++ defining "Klow_zeros_table" in section untraced-data +++
	BYTE 4
	BYTE 0
	BYTE 1
	BYTE 0
	BYTE 2
	BYTE 0
	BYTE 1
	BYTE 0
	BYTE 3
	BYTE 0
	BYTE 1
	BYTE 0
	BYTE 2
	BYTE 0
	BYTE 1
	BYTE 0

+++ defining "Khigh_zeros_table" in section untraced-data +++
	BYTE 4
	BYTE 3
	BYTE 2
	BYTE 2
	BYTE 1
	BYTE 1
	BYTE 1
	BYTE 1
	BYTE 0
	BYTE 0
	BYTE 0
	BYTE 0
	BYTE 0
	BYTE 0
	BYTE 0
	BYTE 0+++ external: "primitive_exit_application" +++

+++ (public) variable{constant "Pmaster_gc_teb"} " in section ambiguous-data" = 0 +++

+++ (public) variable{constant "Pmaster_teb"} " in section ambiguous-data" = 0 +++

+++ (public) variable{indirect-constant "Pteb_tlv_index"} " in section untraced-data" = -1 +++

+++ (public) variable{indirect-constant "Pteb_chain"} " in section untraced-data" = 0 +++
+++ external: "dylan_init_thread" +++
+++ external: "dylan_callin_handler" +++
+++ external: "trampoline_body" +++
+++ external: "dylan_mm_register_thread" +++
+++ external: "dylan_mm_deregister_thread_from_teb" +++
+++ external: "dylan_init_memory_manager" +++
+++ external: "dylan_shut_down_memory_manager" +++
+++ external: "MMRegisterRootStatic" +++
+++ external: "MMRegisterRootImmut" +++
+++ external: "MMRegisterRootAmbig" +++
+++ external: "MMRegisterRootExact" +++
+++ external: "MMDeregisterRoot" +++
+++ external: "MMFreeMisc" +++
+++ external: "Kmake_foreign_threadYthreads_primitivesVdylanI" +++
+++ external: "Kcall_application_exit_functionsVKeI" +++

+++ 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{indirect-constant "Pstarted_unloading"} " 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 +++

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

+++ (public) variable{indirect-constant "Pruntime_thread_count"} " 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" +++

+++ (public) variable{indirect-constant "Prunning_dylan_spy_functionQ"} " in section untraced-data" = 0 +++
+++ external: "spy_invoke_dylan_under_coded_restartVKi" +++
+++ external: "Kmake_simple_lockYthreads_primitivesVdylan" +++

+++ (public) variable{constant "default_tlv_vector"} " in section ambiguous-data" = 0 +++

+++ (public) variable{constant "dylan_false"} " in section untraced-data" = {constant "KPfalseVKi"} +++
+++ external: "Ksignal_low_memoryVKe" +++

+++ (public) variable{constant "dylan_signal_low_memory"} " in section untraced-data" = {constant "Ksignal_low_memoryVKe"} +++
+++ external: "Kkeyboard_break_handlerVKe" +++

+++ (public) variable{constant "dylan_keyboard_break_handler"} " in section untraced-data" = {constant "Kkeyboard_break_handlerVKe"} +++

+++ (public) variable{indirect-constant "dylan_keyboard_interruptQ"} " in section untraced-data" = 0 +++
+++ external: "KPslotacc_single_q_instance_getterVKiI" +++
+++ external: "KPslotacc_single_q_instance_setterVKiI" +++
+++ external: "KPslotacc_single_q_class_getterVKiI" +++
+++ external: "KPslotacc_single_q_class_setterVKiI" +++
+++ external: "KPslotacc_repeated_instance_getterVKiI" +++
+++ external: "KPslotacc_repeated_instance_setterVKiI" +++
+++ external: "Kunbound_instance_slotVKeI" +++
+++ external: "Kunbound_repeated_slotVKeI" +++
+++ external: "Kinvalid_keyword_trapVKeI" +++
+++ external: "Kodd_number_of_keyword_args_trapVKeI" +++
+++ external: "Krepeated_slot_getter_index_out_of_range_trapVKeI" +++
+++ external: "Krepeated_slot_setter_index_out_of_range_trapVKeI" +++
+++ external: "Dinapplicable_engine_nodeVKg" +++
+++ external: "Dabsent_engine_nodeVKg" +++


+++ defining "Kinitialize_engine_node_table" in section untraced-data +++
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_1"
	DATA "initialize_engine_node_table_entries_2"
	DATA "initialize_engine_node_table_entries_3"
	DATA "initialize_engine_node_table_entries_4"
	DATA "initialize_engine_node_table_entries_5"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_default"
	DATA "initialize_engine_node_table_entries_13"
	DATA "initialize_engine_node_table_entries_14"
	DATA "initialize_engine_node_table_entries_1"
	DATA "initialize_engine_node_table_entries_16"
	DATA "initialize_engine_node_table_entries_17"
	DATA "initialize_engine_node_table_entries_18"
	DATA "initialize_engine_node_table_entries_19"
	DATA "initialize_engine_node_table_entries_20"
	DATA "initialize_engine_node_table_entries_21"
	DATA "initialize_engine_node_table_entries_22"
	DATA "initialize_engine_node_table_entries_23"
	DATA "initialize_engine_node_table_entries_20"
	DATA "initialize_engine_node_table_entries_21"
	DATA "initialize_engine_node_table_entries_20"
	DATA "initialize_engine_node_table_entries_21"
	DATA "initialize_engine_node_table_entries_21"
	DATA "initialize_engine_node_table_entries_29"
	DATA "initialize_engine_node_table_entries_21"
	DATA "initialize_engine_node_table_entries_29"+++ external: "KLsymbolGVKdW" +++

+++ (public) variable{indirect-constant "Poblist"} " in section ambiguous-data" = 0 +++

+++ (public) variable{indirect-constant "PoblistUsize"} " in section untraced-data" = 8 +++

+++ (public) variable{indirect-constant "PoblistUcursor"} " in section untraced-data" = 8 +++
+++ external: "Kmachine_word_overflowVKmI" +++
+++ external: "Kinteger_divide_by_0VKeI" +++
+++ external: "Kfloat_divide_by_0VKeI" +++
+++ external: "Kfloat_overflowVKeI" +++
+++ external: "Kfloat_underflowVKeI" +++


+++ defining "Kunsupported_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 45
	BYTE "unsupported"
	BYTE 0

+++ defining "Knan_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 13
	BYTE "nan"
	BYTE 0

+++ defining "Knormal_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 25
	BYTE "normal"
	BYTE 0

+++ defining "Kinfinity_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 33
	BYTE "infinity"
	BYTE 0

+++ defining "Kzero_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 17
	BYTE "zero"
	BYTE 0

+++ defining "Kempty_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 21
	BYTE "empty"
	BYTE 0

+++ defining "Kdenormal_float" in section untraced-objects +++
	DATA "KLbyte_stringGVKdW"
	DATA 33
	BYTE "denormal"
	BYTE 0

+++ defining "Kfloating_point_classes" in section untraced-data +++
	DATA 0
	DATA "Kunsupported_float"
	DATA 256
	DATA "Knan_float"
	DATA 1024
	DATA "Knormal_float"
	DATA 1280
	DATA "Kinfinity_float"
	DATA 16384
	DATA "Kzero_float"
	DATA 16640
	DATA "Kempty_float"
	DATA 17408
	DATA "Kdenormal_float"+++ external: "exit" +++
+++ external: "tlv_create_key" +++
+++ external: "tlv_destroy_key" +++
+++ external: "tlv_get_value" +++
+++ external: "tlv_set_value" +++
+++ external: "getpagesize" +++

+++ 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 +++


+++ Exported function definition primitive_break +++

+++ starting code for primitive_break +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15})
  halt	

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

+++ ending code for primitive_break +++

+++ No Source Code Locators for primitive_break +++


+++ Exported function definition primitive_error +++

+++ starting code for primitive_error +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 25})
  move	eax, {constant "Kprimitive_error_string"}
  move	ebx, {constant "KerrorVKd"}
  move	ecx, 1
  call-indirect	ebx, 4, 1

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

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

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

+++ ending code for primitive_error +++

+++ Live variable scopes for primitive_error +++
Start scope at 3 with frame for no variables
End scope at 20

+++ No Source Code Locators for primitive_error +++


+++ Exported function definition primitive_debug_message +++

+++ starting code for primitive_debug_message +++

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

#() [5->10] (level:0) is green with stack state before
#({basic-block #({tag 7:85}) 85 100}, {basic-block #({tag 1:75}) 75 75})
  beq	{tag 1:75}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0

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

#({tag 2:10}) [80->80] (level:0) is brown with stack state with
#({basic-block #({tag 2:10}) 10 75})

#({tag 2:10}) [10->75] (level:0) is red with stack state with
#({basic-block #({tag 3:80}) 80 80})
  move	G4/eax, eax
  rem	"eliminated"
  load-stack-arg-n	#t, G5/edi, 1
  ld	N2/ebx, G5/edi, 4
  asr	N2/ebx, N2/ebx, 2
  asl	N3/edx, N2/ebx, 2
  sub	esp, esp, N3/edx
  add	N1/edx, G5/edi, 8
  copy-words-down-w	esp, N1/edx, N2/ebx
  push	N2/ebx
  push	G4/eax
  halt	
  pop	eax

#({tag 3:80}) [80->80] (level:0) is yellow with stack state with
#({basic-block #({tag 3:80}, {tag 4:80}) 80 80})

#({tag 3:80}, {tag 4:80}) [80->80] (level:0) is green with stack state with
#({basic-block #({tag 4:80}, {tag 3:80}, {tag 6:80}) 80 85})

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

#({tag 1:75}, {tag 5:75}) [75->80] (level:0) is green with stack state #f
#()
  rts-and-drop	8

#({tag 1:75}) [75->75] (level:0) is green with stack state before
#({basic-block #({tag 1:75}, {tag 5:75}) 75 80})

+++ ending code for primitive_debug_message +++

+++ Live variable scopes for primitive_debug_message +++
Start scope at 12 with frame for no variables
End scope at 43

+++ No Source Code Locators for primitive_debug_message +++


+++ Exported function definition primitive_invoke_debugger +++

+++ starting code for primitive_invoke_debugger +++

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

#({tag 3: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}, {basic-block #({tag 1:25}) 25 75})
  move	G4/eax, eax
  load-stack-arg-n	#t, G5/edi, 0
  bne	{tag 1:25}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0

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

#({tag 1:25}) [25->75] (level:0) is red with stack state with
#({basic-block #({tag 2:80}) 80 85})
  ld	N1/ebx, G5/edi, 4
  asr	N1/ebx, N1/ebx, 2
  asl	N2/edx, N1/ebx, 2
  sub	esp, esp, N2/edx
  add	N0/edx, G5/edi, 8
  copy-words-down-w	esp, N0/edx, N1/ebx
  push	N1/ebx
  push	G4/eax
  halt	
  pop	eax

#({tag 2: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-and-drop	4

+++ ending code for primitive_invoke_debugger +++

+++ Live variable scopes for primitive_invoke_debugger +++
Start scope at 3 with frame for no variables
End scope at 43

+++ No Source Code Locators for primitive_invoke_debugger +++


+++ Exported function definition class_allocation_break +++

+++ starting code for class_allocation_break +++

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

#() [5->10] (level:0) is green with stack state before
#({basic-block #({tag 8:65}) 65 80}, {basic-block #({tag 2:55}) 55 55})
  beq	{tag 2:55}, {indirect-constant "Tclass_profiling_enabledQTVKe"}, {constant "KPtrueVKi"}

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

#({tag 3:10}) [60->60] (level:0) is brown with stack state with
#({basic-block #({tag 3:10}) 10 35})

#({tag 3:10}) [10->35] (level:0) is red with stack state with
#({basic-block #({tag 1:35}) 35 55}, {basic-block #({tag 1:35}) 35 55})
  rem	"eliminated"
  load-stack-arg-n	#t, N1/ecx, 1
  rem	"eliminated"
  load-stack-arg-n	#t, N3/edx, 3
  bne	{tag 1:35}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0

#({tag 1:35}) [35->55] (level:0) is red with stack state with
#({basic-block #({tag 4:60}) 60 60})
  push	N3/edx
  push	N1/ecx
  halt	
  pop	eax

#({tag 4:60}) [60->60] (level:0) is yellow with stack state with
#({basic-block #({tag 4:60}, {tag 5:60}) 60 60})

#({tag 4:60}, {tag 5:60}) [60->60] (level:0) is green with stack state with
#({basic-block #({tag 5:60}, {tag 4:60}, {tag 7:60}) 60 65})

#({tag 5:60}, {tag 4:60}, {tag 7:60}) [60->65] (level:0) is #f with stack state #f
#({basic-block #({tag 2:55}, {tag 6:55}) 55 60})
  preserve-registers-exit	

#({tag 2:55}, {tag 6:55}) [55->60] (level:0) is green with stack state #f
#()
  rts	

#({tag 2:55}) [55->55] (level:0) is green with stack state before
#({basic-block #({tag 2:55}, {tag 6:55}) 55 60})

+++ ending code for class_allocation_break +++

+++ Live variable scopes for class_allocation_break +++
Start scope at 15 with frame for no variables
End scope at 33

+++ No Source Code Locators for class_allocation_break +++


+++ Exported function definition primitive_inside_debuggerQ +++

+++ starting code for primitive_inside_debuggerQ +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:15}) 15 20})
  beq	{tag 1:15}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0

#() [10->15] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 20})
  move	eax, {constant "KPtrueVKi"}

#({tag 2:20}) [20->20] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 25})

#({tag 2:20}) [20->25] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:15}) [15->20] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 20})
  move	eax, {constant "KPfalseVKi"}

#() [25->30] (level:0) is #f with stack state #f
#()
  bra	{tag 2:20}

+++ ending code for primitive_inside_debuggerQ +++

+++ No Source Code Locators for primitive_inside_debuggerQ +++


+++ Exported function definition primitive_allocate +++

+++ starting code for primitive_allocate +++

#() [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	{constant "primitive_error"}, 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-and-drop	0

+++ ending code for primitive_allocate +++

+++ Live variable scopes for primitive_allocate +++
Start scope at 3 with frame for no variables
End scope at 7

+++ No Source Code Locators for primitive_allocate +++


+++ Exported function definition primitive_allocate_filled +++

+++ starting code for primitive_allocate_filled +++

#() [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 75})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->75] (level:0) is red with stack state with
#({basic-block #() 75 85})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/ecx, 1
  load-stack-arg-n	#t, N2/edx, 2
  load-stack-arg-n	#t, N3/ebx, 3
  load-stack-arg-n	#t, N4/edi, 4
  asl	N5/eax, eax, 2
  push	N4/edi
  push	N3/ebx
  push	N2/edx
  push	N1/ecx
  push	N0/NSPILL--1
  push	N5/eax
  call-alien	{constant "primitive_alloc_s_r"}, 0

#() [75->85] (level:0) is red with stack state with
#({basic-block #({tag 1:90}) 90 95})
  add	esp, esp, 24
  move	eax, eax

#({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-and-drop	20

+++ ending code for primitive_allocate_filled +++

+++ Live variable scopes for primitive_allocate_filled +++
Start scope at 3 with frame for no variables
End scope at 34

+++ No Source Code Locators for primitive_allocate_filled +++


+++ Exported function definition primitive_allocate_filled_in_leaf_pool +++

+++ starting code for primitive_allocate_filled_in_leaf_pool +++

#() [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 75})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->75] (level:0) is red with stack state with
#({basic-block #() 75 85})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/ecx, 1
  load-stack-arg-n	#t, N2/edx, 2
  load-stack-arg-n	#t, N3/ebx, 3
  load-stack-arg-n	#t, N4/edi, 4
  asl	N5/eax, eax, 2
  push	N4/edi
  push	N3/ebx
  push	N2/edx
  push	N1/ecx
  push	N0/NSPILL--1
  push	N5/eax
  call-alien	{constant "primitive_alloc_leaf_s_r"}, 0

#() [75->85] (level:0) is red with stack state with
#({basic-block #({tag 1:90}) 90 95})
  add	esp, esp, 24
  move	eax, eax

#({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-and-drop	20

+++ ending code for primitive_allocate_filled_in_leaf_pool +++

+++ Live variable scopes for primitive_allocate_filled_in_leaf_pool +++
Start scope at 3 with frame for no variables
End scope at 34

+++ No Source Code Locators for primitive_allocate_filled_in_leaf_pool +++


+++ Exported function definition primitive_allocate_weak_in_awl_pool +++

+++ starting code for primitive_allocate_weak_in_awl_pool +++

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

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

#() [5->85] (level:0) is red with stack state with
#({basic-block #() 85 95})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/NSPILL--2, 1
  load-stack-arg-n	#t, N2/ecx, 2
  load-stack-arg-n	#t, N3/edx, 3
  load-stack-arg-n	#t, N4/ebx, 4
  load-stack-arg-n	#t, N5/edi, 5
  asl	N6/eax, eax, 2
  push	N4/ebx
  push	N3/edx
  push	N2/ecx
  push	N1/NSPILL--2
  push	N5/edi
  push	N0/NSPILL--1
  push	N6/eax
  call-alien	{constant "primitive_alloc_weak_awl_s_r"}, 0

#() [85->95] (level:0) is red with stack state with
#({basic-block #({tag 1:100}) 100 105})
  add	esp, esp, 28
  move	eax, eax

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

#() [95->100] (level:0) is red with stack state #f
#()
  rts-and-drop	24

+++ ending code for primitive_allocate_weak_in_awl_pool +++

+++ Live variable scopes for primitive_allocate_weak_in_awl_pool +++
Start scope at 3 with frame for no variables
End scope at 37

+++ No Source Code Locators for primitive_allocate_weak_in_awl_pool +++


+++ Exported function definition primitive_allocate_in_awl_pool +++

+++ starting code for primitive_allocate_in_awl_pool +++

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

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

#() [5->85] (level:0) is red with stack state with
#({basic-block #() 85 95})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/NSPILL--2, 1
  load-stack-arg-n	#t, N2/ecx, 2
  load-stack-arg-n	#t, N3/edx, 3
  load-stack-arg-n	#t, N4/ebx, 4
  load-stack-arg-n	#t, N5/edi, 5
  asl	N6/eax, eax, 2
  push	N4/ebx
  push	N3/edx
  push	N2/ecx
  push	N1/NSPILL--2
  push	N5/edi
  push	N0/NSPILL--1
  push	N6/eax
  call-alien	{constant "primitive_alloc_exact_awl_s_r"}, 0

#() [85->95] (level:0) is red with stack state with
#({basic-block #({tag 1:100}) 100 105})
  add	esp, esp, 28
  move	eax, eax

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

#() [95->100] (level:0) is red with stack state #f
#()
  rts-and-drop	24

+++ ending code for primitive_allocate_in_awl_pool +++

+++ Live variable scopes for primitive_allocate_in_awl_pool +++
Start scope at 3 with frame for no variables
End scope at 37

+++ No Source Code Locators for primitive_allocate_in_awl_pool +++


+++ Exported function definition primitive_allocate_wrapper +++

+++ starting code for primitive_allocate_wrapper +++

#() [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 75})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->75] (level:0) is red with stack state with
#({basic-block #() 75 85})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/ecx, 1
  load-stack-arg-n	#t, N2/edx, 2
  load-stack-arg-n	#t, N3/ebx, 3
  load-stack-arg-n	#t, N4/edi, 4
  asl	N5/eax, eax, 2
  push	N4/edi
  push	N3/ebx
  push	N2/edx
  push	N1/ecx
  push	N0/NSPILL--1
  push	N5/eax
  call-alien	{constant "primitive_alloc_wrapper_s_r"}, 0

#() [75->85] (level:0) is red with stack state with
#({basic-block #({tag 1:90}) 90 95})
  add	esp, esp, 24
  move	eax, eax

#({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-and-drop	20

+++ ending code for primitive_allocate_wrapper +++

+++ Live variable scopes for primitive_allocate_wrapper +++
Start scope at 3 with frame for no variables
End scope at 34

+++ No Source Code Locators for primitive_allocate_wrapper +++


+++ Exported function definition primitive_untraced_allocate +++

+++ starting code for primitive_untraced_allocate +++

#() [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 15})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->15] (level:0) is red with stack state with
#({basic-block #() 15 20})
  push	eax
  call-alien	{constant "dylan__malloc__misc"}, 0

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

#({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_untraced_allocate +++

+++ Live variable scopes for primitive_untraced_allocate +++
Start scope at 3 with frame for no variables
End scope at 12

+++ No Source Code Locators for primitive_untraced_allocate +++


+++ Exported function definition primitive_byte_allocate_filled +++

+++ starting code for primitive_byte_allocate_filled +++

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

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

#() [5->95] (level:0) is red with stack state with
#({basic-block #() 95 105})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/NSPILL--2, 1
  load-stack-arg-n	#t, N2/ecx, 2
  load-stack-arg-n	#t, N3/edx, 3
  load-stack-arg-n	#t, N4/ebx, 4
  load-stack-arg-n	#t, N5/edi, 5
  asl	eax, eax, 2
  add	eax, eax, N0/NSPILL--1
  add	eax, eax, 3
  and	eax, eax, -4
  push	N5/edi
  push	N4/ebx
  push	N3/edx
  push	N2/ecx
  push	N1/NSPILL--2
  push	eax
  call-alien	{constant "primitive_alloc_leaf_s_rb"}, 0

#() [95->105] (level:0) is red with stack state with
#({basic-block #({tag 1:110}) 110 115})
  add	esp, esp, 24
  move	eax, eax

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

#() [105->110] (level:0) is red with stack state #f
#()
  rts-and-drop	24

+++ ending code for primitive_byte_allocate_filled +++

+++ Live variable scopes for primitive_byte_allocate_filled +++
Start scope at 3 with frame for no variables
End scope at 43

+++ No Source Code Locators for primitive_byte_allocate_filled +++


+++ Exported function definition primitive_byte_allocate_filled_terminated +++

+++ starting code for primitive_byte_allocate_filled_terminated +++

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

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

#() [5->100] (level:0) is red with stack state with
#({basic-block #() 100 110})
  move	eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  load-stack-arg-n	#t, N1/ecx, 1
  rem	"eliminated"
  load-stack-arg-n	#t, N3/edi, 3
  load-stack-arg-n	#t, N4/edx, 4
  load-stack-arg-n	#t, N5/ebx, 5
  asl	eax, eax, 2
  add	eax, eax, N0/NSPILL--1
  rem	"eliminated"
  add	eax, eax, 3
  and	eax, eax, -4
  asr	N7/edi, N3/edi, 2
  push	N7/edi
  push	N5/ebx
  push	N4/edx
  push	N1/ecx
  push	eax
  call-alien	{constant "primitive_alloc_leaf_rbfz"}, 0

#() [100->110] (level:0) is red with stack state with
#({basic-block #({tag 1:115}) 115 120})
  add	esp, esp, 20
  move	eax, eax

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

#() [110->115] (level:0) is red with stack state #f
#()
  rts-and-drop	24

+++ ending code for primitive_byte_allocate_filled_terminated +++

+++ Live variable scopes for primitive_byte_allocate_filled_terminated +++
Start scope at 3 with frame for no variables
End scope at 43

+++ No Source Code Locators for primitive_byte_allocate_filled_terminated +++


+++ Exported function definition primitive_allocate_vector +++

+++ starting code for primitive_allocate_vector +++

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

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

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 65})
  move	N1/eax, eax
  asl	N2/edi, N1/eax, 2
  add	N2/edi, N2/edi, 8
  push	{constant "KPunboundVKi"}
  push	1
  push	N1/eax
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N2/edi
  call-alien	{constant "primitive_alloc_rf"}, 0

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 1:70}) 70 75})
  add	esp, esp, 20
  move	G0/eax, eax
  move	eax, G0/eax

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

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

+++ ending code for primitive_allocate_vector +++

+++ Live variable scopes for primitive_allocate_vector +++
Start scope at 3 with frame for no variables
End scope at 33

+++ No Source Code Locators for primitive_allocate_vector +++


+++ Exported function definition primitive_vector +++

+++ starting code for primitive_vector +++

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

#() [5->20] (level:0) is green with stack state before
#({basic-block #() 20 25}, {basic-block #({tag 9:125}) 125 140})
  move	N8/eax, eax
  load-address-of-stack-arg-n	#f, N9/edi, 0
  bne	{tag 9:125}, N8/eax, 0

#() [20->25] (level:0) is green with stack state before
#({basic-block #({tag 2:75}) 75 85})
  move	G10/edi, {constant "KPempty_vectorVKi"}

#({tag 2:75}) [75->85] (level:0) is green with stack state before
#({basic-block #({tag 7:85}) 85 90})
  asl	N0/edx, N8/eax, 2
  move	eax, G10/edi

#({tag 7:85}) [85->90] (level:0) is green with stack state #f
#()
  rts-and-drop	N0/edx

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

#({tag 4:90}) [90->100] (level:0) is brown with stack state with
#({basic-block #({tag 3:25}) 25 65})
  move	N1/NSPILL-0, N8/eax
  move	N4/ebx, N9/edi

#({tag 3:25}) [25->65] (level:0) is red with stack state with
#({basic-block #() 65 75})
  asl	N7/edi, N1/NSPILL-0, 2
  add	N7/edi, N7/edi, 8
  push	N4/ebx
  push	1
  push	N1/NSPILL-0
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N7/edi
  call-alien	{constant "primitive_alloc_rt"}, 0

#() [65->75] (level:0) is red with stack state with
#({basic-block #({tag 5:100}) 100 110})
  add	esp, esp, 20
  move	G6/edi, eax

#({tag 5:100}) [100->110] (level:0) is yellow with stack state with
#({basic-block #({tag 6:110}) 110 120})
  move	N8/eax, N1/NSPILL-0
  move	G10/edi, G6/edi

#({tag 6:110}) [110->120] (level:0) is green with stack state with
#({basic-block #({tag 8:120}) 120 125})
  asl	N0/edx, N8/eax, 2
  move	eax, G10/edi

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

#() [140->145] (level:0) is #f with stack state #f
#()
  bra	{tag 7:85}

+++ ending code for primitive_vector +++

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

+++ Live variable scopes for primitive_vector +++
Start scope at 29 with frame for no variables
End scope at 78

+++ No Source Code Locators for primitive_vector +++


+++ Exported function definition primitive_copy_vector +++

+++ starting code for primitive_copy_vector +++

#() [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 8:95}) 95 110})
  move	G6/eax, eax
  ld	N5/edi, G6/eax, 4
  sub	N5/edi, N5/edi, 1
  bne	{tag 8:95}, N5/edi, 0

#() [25->30] (level:0) is green with stack state before
#({basic-block #({tag 1:65}) 60 65})
  move	G7/eax, {constant "KPempty_vectorVKi"}

#({tag 1:65}) [60->65] (level:0) is green with stack state before
#({basic-block #({tag 1:65}, {tag 6:65}) 65 70})
  move	eax, G7/eax

#({tag 1:65}, {tag 6:65}) [65->70] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 8:95}) [95->110] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 70 80})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 3:30}) [70->80] (level:0) is brown with stack state with
#({basic-block #({tag 3:30}, {tag 2:30}) 30 50})
  move	N1/edi, N5/edi
  move	G3/eax, G6/eax

#({tag 3:30}, {tag 2:30}) [30->50] (level:0) is red with stack state with
#({basic-block #() 50 60})
  add	N1/edi, N1/edi, 8
  push	G3/eax
  push	N1/edi
  call-alien	{constant "primitive_copy"}, 0

#() [50->60] (level:0) is red with stack state with
#({basic-block #({tag 4:90}) 80 85})
  add	esp, esp, 8
  move	G4/eax, eax

#({tag 4:90}) [80->85] (level:0) is yellow with stack state with
#({basic-block #({tag 4:90}, {tag 5:90}) 85 90})
  move	G7/eax, G4/eax

#({tag 4:90}, {tag 5:90}) [85->90] (level:0) is green with stack state with
#({basic-block #({tag 5:90}, {tag 4:90}, {tag 7:90}) 90 95})
  move	eax, G7/eax

#({tag 5:90}, {tag 4:90}, {tag 7:90}) [90->95] (level:0) is #f with stack state #f
#({basic-block #({tag 1:65}, {tag 6:65}) 65 70})
  preserve-registers-exit	

#() [110->115] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

+++ ending code for primitive_copy_vector +++

+++ Live variable scopes for primitive_copy_vector +++
Start scope at 20 with frame for no variables
End scope at 33

+++ No Source Code Locators for primitive_copy_vector +++


+++ Exported function definition primitive_make_box +++

+++ starting code for primitive_make_box +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 45})
  move	G0/eax, eax
  push	G0/eax
  push	{constant "KLtraceable_value_cellGVKiW"}
  push	8
  call-alien	{constant "primitive_alloc_s1"}, 0

#() [30->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 50 55})
  add	esp, esp, 12
  move	G1/eax, eax
  move	eax, G1/eax

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

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

+++ ending code for primitive_make_box +++

+++ Live variable scopes for primitive_make_box +++
Start scope at 3 with frame for no variables
End scope at 19

+++ No Source Code Locators for primitive_make_box +++


+++ Exported function definition primitive_make_raw_box +++

+++ starting code for primitive_make_raw_box +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 45})
  move	N0/edi, eax
  push	{constant "KLuntraceable_value_cellGVKiW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 50 55})
  add	esp, esp, 8
  move	G1/eax, eax
  st	N0/edi, G1/eax, 4
  move	eax, G1/eax

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

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

+++ ending code for primitive_make_raw_box +++

+++ Live variable scopes for primitive_make_raw_box +++
Start scope at 3 with frame for no variables
End scope at 23

+++ No Source Code Locators for primitive_make_raw_box +++


+++ Exported function definition primitive_make_single_float_box +++

+++ starting code for primitive_make_single_float_box +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 45})
  fmove	SF0/SFSPILL-0, ST
  push	{constant "KLuntraceable_value_cellGVKiW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 50 55})
  add	esp, esp, 8
  move	G1/eax, eax
  fst	SF0/SFSPILL-0, G1/eax, 4
  move	eax, G1/eax

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

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

+++ ending code for primitive_make_single_float_box +++

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

+++ Live variable scopes for primitive_make_single_float_box +++
Start scope at 3 with frame for no variables
End scope at 30

+++ No Source Code Locators for primitive_make_single_float_box +++


+++ Exported function definition primitive_make_double_float_box +++

+++ starting code for primitive_make_double_float_box +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 45})
  dmove	DF0/DFSPILL-0, ST
  push	{constant "KLuntraceable_double_value_cellGVKiW"}
  push	12
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 50 55})
  add	esp, esp, 8
  move	G1/eax, eax
  dst	DF0/DFSPILL-0, G1/eax, 4
  move	eax, G1/eax

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

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

+++ ending code for primitive_make_double_float_box +++

+++ Frame sizes for primitive_make_double_float_box: GC: 0, NC: 2 +++

+++ Live variable scopes for primitive_make_double_float_box +++
Start scope at 3 with frame for no variables
End scope at 30

+++ No Source Code Locators for primitive_make_double_float_box +++


+++ Exported function definition primitive_make_closure +++

+++ starting code for primitive_make_closure +++

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

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

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 65})
  move	G1/eax, eax
  load-stack-arg-n	#t, N0/edi, 0
  asl	N4/ebx, N0/edi, 2
  add	N3/ebx, N4/ebx, 20
  push	G1/eax
  push	4
  push	N0/edi
  push	N3/ebx
  call-alien	{constant "primitive_copy_r"}, 0

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 1:70}) 70 75})
  add	esp, esp, 16
  move	G2/eax, eax
  move	eax, G2/eax

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

#() [65->70] (level:0) is red with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_make_closure +++

+++ Live variable scopes for primitive_make_closure +++
Start scope at 3 with frame for no variables
End scope at 27

+++ No Source Code Locators for primitive_make_closure +++


+++ Exported function definition primitive_make_keyword_closure +++

+++ starting code for primitive_make_keyword_closure +++

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

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

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 65})
  move	G1/eax, eax
  load-stack-arg-n	#t, N0/edi, 0
  asl	N4/ebx, N0/edi, 2
  add	N3/ebx, N4/ebx, 28
  push	G1/eax
  push	6
  push	N0/edi
  push	N3/ebx
  call-alien	{constant "primitive_copy_r"}, 0

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 1:70}) 70 75})
  add	esp, esp, 16
  move	G2/eax, eax
  move	eax, G2/eax

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

#() [65->70] (level:0) is red with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_make_keyword_closure +++

+++ Live variable scopes for primitive_make_keyword_closure +++
Start scope at 3 with frame for no variables
End scope at 27

+++ No Source Code Locators for primitive_make_keyword_closure +++


+++ Exported function definition primitive_make_closure_with_signature +++

+++ starting code for primitive_make_closure_with_signature +++

#() [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 55})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->55] (level:0) is red with stack state with
#({basic-block #() 55 75})
  move	G1/eax, eax
  load-stack-arg-n	#t, G3/GSPILL--1, 0
  load-stack-arg-n	#t, N0/edi, 1
  asl	N5/ebx, N0/edi, 2
  add	N4/ebx, N5/ebx, 20
  push	G1/eax
  push	4
  push	N0/edi
  push	N4/ebx
  call-alien	{constant "primitive_copy_r"}, 0

#() [55->75] (level:0) is red with stack state with
#({basic-block #({tag 1:80}) 80 85})
  add	esp, esp, 16
  move	G2/eax, eax
  move	eax, G2/eax
  st	G3/GSPILL--1, eax, 8

#({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-and-drop	8

+++ ending code for primitive_make_closure_with_signature +++

+++ Live variable scopes for primitive_make_closure_with_signature +++
Start scope at 3 with frame for no variables
End scope at 33

+++ No Source Code Locators for primitive_make_closure_with_signature +++


+++ Exported function definition primitive_make_keyword_closure_with_signature +++

+++ starting code for primitive_make_keyword_closure_with_signature +++

#() [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 55})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->55] (level:0) is red with stack state with
#({basic-block #() 55 75})
  move	G1/eax, eax
  load-stack-arg-n	#t, G3/GSPILL--1, 0
  load-stack-arg-n	#t, N0/edi, 1
  asl	N5/ebx, N0/edi, 2
  add	N4/ebx, N5/ebx, 28
  push	G1/eax
  push	6
  push	N0/edi
  push	N4/ebx
  call-alien	{constant "primitive_copy_r"}, 0

#() [55->75] (level:0) is red with stack state with
#({basic-block #({tag 1:80}) 80 85})
  add	esp, esp, 16
  move	G2/eax, eax
  move	eax, G2/eax
  st	G3/GSPILL--1, eax, 8

#({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-and-drop	8

+++ ending code for primitive_make_keyword_closure_with_signature +++

+++ Live variable scopes for primitive_make_keyword_closure_with_signature +++
Start scope at 3 with frame for no variables
End scope at 33

+++ No Source Code Locators for primitive_make_keyword_closure_with_signature +++


+++ Exported function definition primitive_initialize_closure +++

+++ starting code for primitive_initialize_closure +++

#() [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 #({tag 6:90}) 90 105}, {basic-block #({tag 1:80}) 80 80})
  move	G2/ecx, eax
  load-stack-arg-n	#f, N0/ebx, 0
  move	N1/edi, 4
  beq	{tag 1:80}, N0/ebx, 0

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

#() [25->80] (level:0) is green with stack state with
#({basic-block #({tag 3:85}) 85 85})
  move	N6/edx, N1/edi
  add	N4/edi, G2/ecx, 20
  move	N5/ecx, N0/ebx
  load-address-of-stack-arg-n	#t, N3/NSPILL-0, 1
  move	edi, N4/edi
  move	esi, N3/NSPILL-0
  copy-words-down-w	edi, esi, N5/ecx
  move	N7/ebx, N0/ebx
  asl	N7/ebx, N7/ebx, 2
  move	N1/edi, N6/edx
  add	N1/edi, N1/edi, N7/ebx

#({tag 3:85}) [85->85] (level:0) is green with stack state with
#({basic-block #({tag 3:85}, {tag 5:85}) 85 90})

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

#({tag 1:80}, {tag 4:80}) [80->85] (level:0) is green with stack state #f
#()
  rts-and-drop	N1/edi

#({tag 1:80}) [80->80] (level:0) is green with stack state before
#({basic-block #({tag 1:80}, {tag 4:80}) 80 85})

+++ ending code for primitive_initialize_closure +++

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

+++ Live variable scopes for primitive_initialize_closure +++
Start scope at 19 with frame for no variables
End scope at 47

+++ No Source Code Locators for primitive_initialize_closure +++


+++ Exported function definition primitive_initialize_keyword_closure +++

+++ starting code for primitive_initialize_keyword_closure +++

#() [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 #({tag 6:90}) 90 105}, {basic-block #({tag 1:80}) 80 80})
  move	G2/ecx, eax
  load-stack-arg-n	#f, N0/ebx, 0
  move	N1/edi, 4
  beq	{tag 1:80}, N0/ebx, 0

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

#() [25->80] (level:0) is green with stack state with
#({basic-block #({tag 3:85}) 85 85})
  move	N6/edx, N1/edi
  add	N4/edi, G2/ecx, 28
  move	N5/ecx, N0/ebx
  load-address-of-stack-arg-n	#t, N3/NSPILL-0, 1
  move	edi, N4/edi
  move	esi, N3/NSPILL-0
  copy-words-down-w	edi, esi, N5/ecx
  move	N7/ebx, N0/ebx
  asl	N7/ebx, N7/ebx, 2
  move	N1/edi, N6/edx
  add	N1/edi, N1/edi, N7/ebx

#({tag 3:85}) [85->85] (level:0) is green with stack state with
#({basic-block #({tag 3:85}, {tag 5:85}) 85 90})

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

#({tag 1:80}, {tag 4:80}) [80->85] (level:0) is green with stack state #f
#()
  rts-and-drop	N1/edi

#({tag 1:80}) [80->80] (level:0) is green with stack state before
#({basic-block #({tag 1:80}, {tag 4:80}) 80 85})

+++ ending code for primitive_initialize_keyword_closure +++

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

+++ Live variable scopes for primitive_initialize_keyword_closure +++
Start scope at 19 with frame for no variables
End scope at 47

+++ No Source Code Locators for primitive_initialize_keyword_closure +++


+++ Exported function definition primitive_make_closure_with_environment +++

+++ starting code for primitive_make_closure_with_environment +++

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

#({tag 4:140}) [140->155] (level:0) is #f with stack state #f
#({basic-block #() 5 50})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 70})
  move	G2/eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  asl	N10/edi, N0/NSPILL--1, 2
  add	N9/edi, N10/edi, 20
  push	G2/eax
  push	4
  push	N0/NSPILL--1
  push	N9/edi
  call-alien	{constant "primitive_copy_r"}, 0

#() [50->70] (level:0) is red with stack state with
#({basic-block #() 70 125}, {basic-block #({tag 1:135}) 125 130})
  add	esp, esp, 16
  move	G3/eax, eax
  move	N1/edi, 4
  beq	{tag 1:135}, N0/NSPILL--1, 0

#() [70->125] (level:0) is red with stack state with
#({basic-block #({tag 1:135}) 125 130})
  move	N7/edx, N1/edi
  add	N5/edi, G3/eax, 20
  move	N6/ecx, N0/NSPILL--1
  load-address-of-stack-arg-n	#t, N4/ebx, 1
  move	edi, N5/edi
  move	esi, N4/ebx
  copy-words-down-w	edi, esi, N6/ecx
  move	N8/ebx, N0/NSPILL--1
  asl	N8/ebx, N8/ebx, 2
  move	N1/edi, N7/edx
  add	N1/edi, N1/edi, N8/ebx

#({tag 1:135}) [125->130] (level:0) is red with stack state with
#({basic-block #({tag 1:135}, {tag 3:135}) 135 140})
  move	eax, G3/eax

#({tag 1:135}, {tag 3:135}) [135->140] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  preserve-registers-exit	

#() [130->135] (level:0) is red with stack state #f
#()
  rts-and-drop	N1/edi

+++ ending code for primitive_make_closure_with_environment +++

+++ Live variable scopes for primitive_make_closure_with_environment +++
Start scope at 3 with frame for no variables
End scope at 64

+++ No Source Code Locators for primitive_make_closure_with_environment +++


+++ Exported function definition primitive_make_keyword_closure_with_environment +++

+++ starting code for primitive_make_keyword_closure_with_environment +++

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

#({tag 4:140}) [140->155] (level:0) is #f with stack state #f
#({basic-block #() 5 50})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 70})
  move	G2/eax, eax
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  asl	N10/edi, N0/NSPILL--1, 2
  add	N9/edi, N10/edi, 28
  push	G2/eax
  push	6
  push	N0/NSPILL--1
  push	N9/edi
  call-alien	{constant "primitive_copy_r"}, 0

#() [50->70] (level:0) is red with stack state with
#({basic-block #() 70 125}, {basic-block #({tag 1:135}) 125 130})
  add	esp, esp, 16
  move	G3/eax, eax
  move	N1/edi, 4
  beq	{tag 1:135}, N0/NSPILL--1, 0

#() [70->125] (level:0) is red with stack state with
#({basic-block #({tag 1:135}) 125 130})
  move	N7/edx, N1/edi
  add	N5/edi, G3/eax, 28
  move	N6/ecx, N0/NSPILL--1
  load-address-of-stack-arg-n	#t, N4/ebx, 1
  move	edi, N5/edi
  move	esi, N4/ebx
  copy-words-down-w	edi, esi, N6/ecx
  move	N8/ebx, N0/NSPILL--1
  asl	N8/ebx, N8/ebx, 2
  move	N1/edi, N7/edx
  add	N1/edi, N1/edi, N8/ebx

#({tag 1:135}) [125->130] (level:0) is red with stack state with
#({basic-block #({tag 1:135}, {tag 3:135}) 135 140})
  move	eax, G3/eax

#({tag 1:135}, {tag 3:135}) [135->140] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  preserve-registers-exit	

#() [130->135] (level:0) is red with stack state #f
#()
  rts-and-drop	N1/edi

+++ ending code for primitive_make_keyword_closure_with_environment +++

+++ Live variable scopes for primitive_make_keyword_closure_with_environment +++
Start scope at 3 with frame for no variables
End scope at 64

+++ No Source Code Locators for primitive_make_keyword_closure_with_environment +++


+++ Exported function definition primitive_make_closure_with_environment_signature +++

+++ starting code for primitive_make_closure_with_environment_signature +++

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

#({tag 4:150}) [150->165] (level:0) is #f with stack state #f
#({basic-block #() 5 55})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->55] (level:0) is red with stack state with
#({basic-block #() 55 75})
  move	G2/eax, eax
  load-stack-arg-n	#t, G3/GSPILL--1, 0
  load-stack-arg-n	#t, N0/NSPILL--2, 1
  asl	N11/edi, N0/NSPILL--2, 2
  add	N10/edi, N11/edi, 20
  push	G2/eax
  push	4
  push	N0/NSPILL--2
  push	N10/edi
  call-alien	{constant "primitive_copy_r"}, 0

#() [55->75] (level:0) is red with stack state with
#({basic-block #() 75 130}, {basic-block #({tag 1:130}) 130 140})
  add	esp, esp, 16
  move	G4/eax, eax
  move	N1/edi, 8
  beq	{tag 1:130}, N0/NSPILL--2, 0

#() [75->130] (level:0) is red with stack state with
#({basic-block #({tag 1:130}) 130 140})
  move	N8/edx, N1/edi
  add	N6/edi, G4/eax, 20
  move	N7/ecx, N0/NSPILL--2
  load-address-of-stack-arg-n	#t, N5/ebx, 2
  move	edi, N6/edi
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N7/ecx
  move	N9/ebx, N0/NSPILL--2
  asl	N9/ebx, N9/ebx, 2
  move	N1/edi, N8/edx
  add	N1/edi, N1/edi, N9/ebx

#({tag 1:130}) [130->140] (level:0) is red with stack state with
#({basic-block #({tag 3:145}) 145 150})
  move	eax, G4/eax
  st	G3/GSPILL--1, eax, 8

#({tag 3:145}) [145->150] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  preserve-registers-exit	

#() [140->145] (level:0) is red with stack state #f
#()
  rts-and-drop	N1/edi

+++ ending code for primitive_make_closure_with_environment_signature +++

+++ Live variable scopes for primitive_make_closure_with_environment_signature +++
Start scope at 3 with frame for no variables
End scope at 70

+++ No Source Code Locators for primitive_make_closure_with_environment_signature +++


+++ Exported function definition primitive_make_keyword_closure_with_environment_signature +++

+++ starting code for primitive_make_keyword_closure_with_environment_signature +++

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

#({tag 4:150}) [150->165] (level:0) is #f with stack state #f
#({basic-block #() 5 55})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->55] (level:0) is red with stack state with
#({basic-block #() 55 75})
  move	G2/eax, eax
  load-stack-arg-n	#t, G3/GSPILL--1, 0
  load-stack-arg-n	#t, N0/NSPILL--2, 1
  asl	N11/edi, N0/NSPILL--2, 2
  add	N10/edi, N11/edi, 28
  push	G2/eax
  push	6
  push	N0/NSPILL--2
  push	N10/edi
  call-alien	{constant "primitive_copy_r"}, 0

#() [55->75] (level:0) is red with stack state with
#({basic-block #() 75 130}, {basic-block #({tag 1:130}) 130 140})
  add	esp, esp, 16
  move	G4/eax, eax
  move	N1/edi, 8
  beq	{tag 1:130}, N0/NSPILL--2, 0

#() [75->130] (level:0) is red with stack state with
#({basic-block #({tag 1:130}) 130 140})
  move	N8/edx, N1/edi
  add	N6/edi, G4/eax, 28
  move	N7/ecx, N0/NSPILL--2
  load-address-of-stack-arg-n	#t, N5/ebx, 2
  move	edi, N6/edi
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N7/ecx
  move	N9/ebx, N0/NSPILL--2
  asl	N9/ebx, N9/ebx, 2
  move	N1/edi, N8/edx
  add	N1/edi, N1/edi, N9/ebx

#({tag 1:130}) [130->140] (level:0) is red with stack state with
#({basic-block #({tag 3:145}) 145 150})
  move	eax, G4/eax
  st	G3/GSPILL--1, eax, 8

#({tag 3:145}) [145->150] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  preserve-registers-exit	

#() [140->145] (level:0) is red with stack state #f
#()
  rts-and-drop	N1/edi

+++ ending code for primitive_make_keyword_closure_with_environment_signature +++

+++ Live variable scopes for primitive_make_keyword_closure_with_environment_signature +++
Start scope at 3 with frame for no variables
End scope at 70

+++ No Source Code Locators for primitive_make_keyword_closure_with_environment_signature +++


+++ Exported function definition primitive_make_method_with_signature +++

+++ starting code for primitive_make_method_with_signature +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 50})
  move	G0/eax, eax
  load-stack-arg-n	#t, G1/edi, 0
  push	G0/eax
  push	16
  call-alien	{constant "primitive_copy"}, 0

#() [30->50] (level:0) is red with stack state with
#({basic-block #({tag 1:55}) 55 60})
  add	esp, esp, 8
  move	G2/eax, eax
  move	eax, G2/eax
  st	G1/edi, eax, 8

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

#() [50->55] (level:0) is red with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_make_method_with_signature +++

+++ Live variable scopes for primitive_make_method_with_signature +++
Start scope at 3 with frame for no variables
End scope at 20

+++ No Source Code Locators for primitive_make_method_with_signature +++


+++ Exported function definition primitive_make_keyword_method_with_signature +++

+++ starting code for primitive_make_keyword_method_with_signature +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 50})
  move	G0/eax, eax
  load-stack-arg-n	#t, G1/edi, 0
  push	G0/eax
  push	24
  call-alien	{constant "primitive_copy"}, 0

#() [30->50] (level:0) is red with stack state with
#({basic-block #({tag 1:55}) 55 60})
  add	esp, esp, 8
  move	G2/eax, eax
  move	eax, G2/eax
  st	G1/edi, eax, 8

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

#() [50->55] (level:0) is red with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_make_keyword_method_with_signature +++

+++ Live variable scopes for primitive_make_keyword_method_with_signature +++
Start scope at 3 with frame for no variables
End scope at 20

+++ No Source Code Locators for primitive_make_keyword_method_with_signature +++


+++ Exported function definition primitive_strlen +++

+++ starting code for primitive_strlen +++

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

#() [5->15] (level:0) is green with stack state #f
#({basic-block #({tag 5:15}) 15 25})
  move	N0/edi, eax
  move	N1/eax, eax

#({tag 5:15}) [15->25] (level:1) is green with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:60}) 60 65})
  ld	N2/ebx, N1/eax, 0
  beq-byte	{tag 1:60}, N2/ebx, 0

#() [25->30] (level:1) is green with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 2:55}) 55 60})
  bnand	{tag 2:55}, N2/ebx, 65280

#() [30->35] (level:1) is green with stack state #f
#({basic-block #() 35 45}, {basic-block #({tag 3:50}) 50 55})
  bnand	{tag 3:50}, N2/ebx, 16711680

#() [35->45] (level:1) is green with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 5:15}) 15 25})
  add	N1/eax, N1/eax, 4
  band	{tag 5:15}, N2/ebx, #ex00000000FF000000

#() [45->50] (level:0) is green with stack state #f
#({basic-block #({tag 3:50}) 50 55})
  sub	N1/eax, N1/eax, 3

#({tag 3:50}) [50->55] (level:0) is green with stack state #f
#({basic-block #({tag 2:55}) 55 60})
  add	N1/eax, N1/eax, 1

#({tag 2:55}) [55->60] (level:0) is green with stack state #f
#({basic-block #({tag 1:60}) 60 65})
  add	N1/eax, N1/eax, 1

#({tag 1:60}) [60->65] (level:0) is green with stack state #f
#({basic-block #() 65 70})
  sub	eax, N1/eax, N0/edi

#() [65->70] (level:0) is green with stack state #f
#()
  rts-and-drop	0

+++ ending code for primitive_strlen +++

+++ No Source Code Locators for primitive_strlen +++


+++ Exported function definition primitive_raw_as_string +++

+++ starting code for primitive_raw_as_string +++

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

#({tag 2:100}) [100->115] (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 60})
  move	N0/NSPILL-1, eax
  call	{constant "primitive_strlen"}, 1

#() [15->60] (level:0) is red with stack state with
#({basic-block #() 60 90})
  move	N1/NSPILL-0, eax
  add	N2/edi, N1/NSPILL-0, 12
  and	N2/edi, N2/edi, -4
  move	N3/ebx, N1/NSPILL-0
  push	1
  push	N3/ebx
  push	{constant "KLbyte_stringGVKdW"}
  push	N2/edi
  call-alien	{constant "primitive_alloc_leaf_r"}, 0

#() [60->90] (level:0) is red with stack state with
#({basic-block #({tag 1:95}) 95 100})
  add	esp, esp, 16
  move	G5/eax, eax
  add	N4/edi, G5/eax, 8
  add	N1/NSPILL-0, N1/NSPILL-0, 1
  copy-bytes-down	N4/edi, N0/NSPILL-1, N1/NSPILL-0
  move	eax, G5/eax

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

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

+++ ending code for primitive_raw_as_string +++

+++ Frame sizes for primitive_raw_as_string: GC: 0, NC: 2 +++

+++ Live variable scopes for primitive_raw_as_string +++
Start scope at 3 with frame for no variables
End scope at 73

+++ No Source Code Locators for primitive_raw_as_string +++


+++ Exported function definition primitive_random +++

+++ starting code for primitive_random +++

#() [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	{constant "primitive_error"}, 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-and-drop	0

+++ ending code for primitive_random +++

+++ Live variable scopes for primitive_random +++
Start scope at 3 with frame for no variables
End scope at 7

+++ No Source Code Locators for primitive_random +++


+++ Exported function definition primitive_arg_error +++

+++ starting code for primitive_arg_error +++

#() [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	{constant "primitive_error"}, 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-and-drop	0

+++ ending code for primitive_arg_error +++

+++ Live variable scopes for primitive_arg_error +++
Start scope at 3 with frame for no variables
End scope at 7

+++ No Source Code Locators for primitive_arg_error +++


+++ Exported function definition primitive_raw_as_single_float +++

+++ starting code for primitive_raw_as_single_float +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 50})
  fmove	SF0/SFSPILL-0, ST
  push	{constant "KLsingle_floatGVKdW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->50] (level:0) is red with stack state with
#({basic-block #({tag 1:55}) 55 60})
  add	esp, esp, 8
  move	G2/eax, eax
  move	eax, G2/eax
  move-from-sfreg	N1/edi, SF0/SFSPILL-0
  st	N1/edi, eax, 4

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

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

+++ ending code for primitive_raw_as_single_float +++

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

+++ Live variable scopes for primitive_raw_as_single_float +++
Start scope at 3 with frame for no variables
End scope at 30

+++ No Source Code Locators for primitive_raw_as_single_float +++


+++ Exported function definition primitive_raw_as_double_float +++

+++ starting code for primitive_raw_as_double_float +++

#() [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 25})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 55})
  dmove	DF0/DFSPILL-0, ST
  push	{constant "KLdouble_floatGVKdW"}
  push	12
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->55] (level:0) is red with stack state with
#({basic-block #({tag 1:60}) 60 65})
  add	esp, esp, 8
  move	G3/eax, eax
  move	eax, G3/eax
  move-from-dfreg	N1/ebx, N2/edi, DF0/DFSPILL-0
  st	N1/ebx, eax, 4
  st	N2/edi, eax, 8

#({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-and-drop	0

+++ ending code for primitive_raw_as_double_float +++

+++ Frame sizes for primitive_raw_as_double_float: GC: 0, NC: 2 +++

+++ Live variable scopes for primitive_raw_as_double_float +++
Start scope at 3 with frame for no variables
End scope at 36

+++ No Source Code Locators for primitive_raw_as_double_float +++


+++ Exported function definition primitive_wrap_machine_word +++

+++ starting code for primitive_wrap_machine_word +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 45})
  move	N1/edi, eax
  push	{constant "KLmachine_wordGVKeW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [25->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 50 55})
  add	esp, esp, 8
  move	G0/eax, eax
  move	eax, G0/eax
  st	N1/edi, eax, 4

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

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

+++ ending code for primitive_wrap_machine_word +++

+++ Live variable scopes for primitive_wrap_machine_word +++
Start scope at 3 with frame for no variables
End scope at 23

+++ No Source Code Locators for primitive_wrap_machine_word +++


+++ Exported function definition primitive_wrap_c_pointer +++

+++ starting code for primitive_wrap_c_pointer +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 50})
  move	G2/eax, eax
  load-stack-arg-n	#t, N0/edi, 0
  push	G2/eax
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [30->50] (level:0) is red with stack state with
#({basic-block #({tag 1:55}) 55 60})
  add	esp, esp, 8
  move	G1/eax, eax
  move	eax, G1/eax
  st	N0/edi, eax, 4

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

#() [50->55] (level:0) is red with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_wrap_c_pointer +++

+++ Live variable scopes for primitive_wrap_c_pointer +++
Start scope at 3 with frame for no variables
End scope at 20

+++ No Source Code Locators for primitive_wrap_c_pointer +++


+++ Exported function definition primitive_wrap_abstract_integer +++

+++ starting code for primitive_wrap_abstract_integer +++

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

#() [5->10] (level:0) is green with stack state before
#({basic-block #() 10 15}, {basic-block #({tag 8:70}) 70 85})
  bgt	{tag 8:70}, eax, 536870911

#() [10->15] (level:0) is green with stack state before
#({basic-block #() 15 25}, {basic-block #({tag 8:70}) 70 85})
  blt	{tag 8:70}, eax, -536870912

#() [15->25] (level:0) is green with stack state before
#({basic-block #({tag 2:25}) 25 25})
  asl	eax, eax, 2
  add	eax, eax, 1

#({tag 2:25}) [25->25] (level:0) is green with stack state before
#({basic-block #({tag 2:25}, {tag 6:25}) 25 30})

#({tag 2:25}, {tag 6:25}) [25->30] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 8:70}) [70->85] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 65 65})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 3:30}) [65->65] (level:0) is brown with stack state with
#({basic-block #({tag 3:30}, {tag 1:30}) 30 50})

#({tag 3:30}, {tag 1:30}) [30->50] (level:0) is red with stack state with
#({basic-block #() 50 65})
  move	N0/edi, eax
  push	{constant "KLmachine_wordGVKeW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 4:65}) 65 65})
  add	esp, esp, 8
  move	eax, eax
  st	N0/edi, eax, 4

#({tag 4:65}) [65->65] (level:0) is yellow with stack state with
#({basic-block #({tag 4:65}, {tag 5:65}) 65 65})

#({tag 4:65}, {tag 5:65}) [65->65] (level:0) is green with stack state with
#({basic-block #({tag 5:65}, {tag 4:65}, {tag 7:65}) 65 70})

#({tag 5:65}, {tag 4:65}, {tag 7:65}) [65->70] (level:0) is #f with stack state #f
#({basic-block #({tag 2:25}, {tag 6:25}) 25 30})
  preserve-registers-exit	

#() [85->90] (level:0) is #f with stack state #f
#()
  bra	{tag 2:25}

+++ ending code for primitive_wrap_abstract_integer +++

+++ Live variable scopes for primitive_wrap_abstract_integer +++
Start scope at 24 with frame for no variables
End scope at 44

+++ No Source Code Locators for primitive_wrap_abstract_integer +++


+++ Exported function definition primitive_wrap_unsigned_abstract_integer +++

+++ starting code for primitive_wrap_unsigned_abstract_integer +++

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

#() [5->10] (level:0) is green with stack state before
#({basic-block #() 10 20}, {basic-block #({tag 8:65}) 65 80})
  bhi	{tag 8:65}, eax, 536870911

#() [10->20] (level:0) is green with stack state before
#({basic-block #({tag 2:20}) 20 20})
  asl	eax, eax, 2
  add	eax, eax, 1

#({tag 2:20}) [20->20] (level:0) is green with stack state before
#({basic-block #({tag 2:20}, {tag 6:20}) 20 25})

#({tag 2:20}, {tag 6:20}) [20->25] (level:0) is green with stack state #f
#()
  rts-and-drop	0

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

#({tag 3:25}) [60->60] (level:0) is brown with stack state with
#({basic-block #({tag 3:25}, {tag 1:25}) 25 45})

#({tag 3:25}, {tag 1:25}) [25->45] (level:0) is red with stack state with
#({basic-block #() 45 60})
  move	N0/edi, eax
  push	{constant "KLmachine_wordGVKeW"}
  push	8
  call-alien	{constant "primitive_alloc_leaf"}, 0

#() [45->60] (level:0) is red with stack state with
#({basic-block #({tag 4:60}) 60 60})
  add	esp, esp, 8
  move	eax, eax
  st	N0/edi, eax, 4

#({tag 4:60}) [60->60] (level:0) is yellow with stack state with
#({basic-block #({tag 4:60}, {tag 5:60}) 60 60})

#({tag 4:60}, {tag 5:60}) [60->60] (level:0) is green with stack state with
#({basic-block #({tag 5:60}, {tag 4:60}, {tag 7:60}) 60 65})

#({tag 5:60}, {tag 4:60}, {tag 7:60}) [60->65] (level:0) is #f with stack state #f
#({basic-block #({tag 2:20}, {tag 6:20}) 20 25})
  preserve-registers-exit	

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 2:20}

+++ ending code for primitive_wrap_unsigned_abstract_integer +++

+++ Live variable scopes for primitive_wrap_unsigned_abstract_integer +++
Start scope at 17 with frame for no variables
End scope at 37

+++ No Source Code Locators for primitive_wrap_unsigned_abstract_integer +++


+++ Exported function definition primitive_unwrap_abstract_integer +++

+++ starting code for primitive_unwrap_abstract_integer +++

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

#() [5->15] (level:0) is green with stack state #f
#({basic-block #() 15 20}, {basic-block #({tag 1:25}) 25 30})
  and	N0/edi, eax, 3
  beq	{tag 1:25}, N0/edi, 0

#() [15->20] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 20})
  asr	eax, eax, 2

#({tag 2:20}) [20->20] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 25})

#({tag 2:20}) [20->25] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:25}) [25->30] (level:0) is green with stack state #f
#({basic-block #({tag 2:20}) 20 20})
  ld	eax, eax, 4

#() [30->35] (level:0) is #f with stack state #f
#()
  bra	{tag 2:20}

+++ ending code for primitive_unwrap_abstract_integer +++

+++ No Source Code Locators for primitive_unwrap_abstract_integer +++


+++ Exported function definition primitive_machine_word_count_low_zeros +++

+++ starting code for primitive_machine_word_count_low_zeros +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 35})
  bne	{tag 1:20}, eax, 0

#() [10->15] (level:0) is green with stack state #f
#({basic-block #() 15 20})
  move	eax, 32

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

#({tag 1:20}) [20->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 2:75}) 75 80})
  move	N1/eax, eax
  move	N0/edi, 0
  bne-byte	{tag 2:75}, N1/eax, 0

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 3:65}) 65 75})
  band	{tag 3:65}, N1/eax, 65280

#() [40->45] (level:0) is green with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 4:55}) 55 65})
  band	{tag 4:55}, N1/eax, 16711680

#() [45->55] (level:0) is green with stack state #f
#({basic-block #({tag 4:55}) 55 65})
  add	N0/edi, N0/edi, 8
  lsr	N1/eax, N1/eax, 8

#({tag 4:55}) [55->65] (level:0) is green with stack state #f
#({basic-block #({tag 3:65}) 65 75})
  add	N0/edi, N0/edi, 8
  lsr	N1/eax, N1/eax, 8

#({tag 3:65}) [65->75] (level:0) is green with stack state #f
#({basic-block #({tag 2:75}) 75 80})
  add	N0/edi, N0/edi, 8
  lsr	N1/eax, N1/eax, 8

#({tag 2:75}) [75->80] (level:0) is green with stack state #f
#({basic-block #() 80 90}, {basic-block #({tag 5:90}) 90 105})
  band	{tag 5:90}, N1/eax, 15

#() [80->90] (level:0) is green with stack state #f
#({basic-block #({tag 5:90}) 90 105})
  add	N0/edi, N0/edi, 4
  lsr	N1/eax, N1/eax, 4

#({tag 5:90}) [90->105] (level:0) is green with stack state #f
#({basic-block #() 105 110})
  and	N1/eax, N1/eax, 15
  ldb	N1/eax, {constant "Klow_zeros_table"}, N1/eax
  add	eax, N0/edi, N1/eax

#() [105->110] (level:0) is green with stack state #f
#()
  rts-and-drop	0

+++ ending code for primitive_machine_word_count_low_zeros +++

+++ No Source Code Locators for primitive_machine_word_count_low_zeros +++


+++ Exported function definition primitive_machine_word_count_high_zeros +++

+++ starting code for primitive_machine_word_count_high_zeros +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 35})
  bne	{tag 1:20}, eax, 0

#() [10->15] (level:0) is green with stack state #f
#({basic-block #() 15 20})
  move	eax, 32

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

#({tag 1:20}) [20->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 2:75}) 75 80})
  move	N1/eax, eax
  move	N0/edi, 0
  band	{tag 2:75}, N1/eax, #ex00000000FF000000

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 3:65}) 65 75})
  band	{tag 3:65}, N1/eax, 16711680

#() [40->45] (level:0) is green with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 4:55}) 55 65})
  band	{tag 4:55}, N1/eax, 65280

#() [45->55] (level:0) is green with stack state #f
#({basic-block #({tag 4:55}) 55 65})
  add	N0/edi, N0/edi, 8
  asl	N1/eax, N1/eax, 8

#({tag 4:55}) [55->65] (level:0) is green with stack state #f
#({basic-block #({tag 3:65}) 65 75})
  add	N0/edi, N0/edi, 8
  asl	N1/eax, N1/eax, 8

#({tag 3:65}) [65->75] (level:0) is green with stack state #f
#({basic-block #({tag 2:75}) 75 80})
  add	N0/edi, N0/edi, 8
  asl	N1/eax, N1/eax, 8

#({tag 2:75}) [75->80] (level:0) is green with stack state #f
#({basic-block #() 80 90}, {basic-block #({tag 5:90}) 90 105})
  band	{tag 5:90}, N1/eax, #ex00000000F0000000

#() [80->90] (level:0) is green with stack state #f
#({basic-block #({tag 5:90}) 90 105})
  add	N0/edi, N0/edi, 4
  asl	N1/eax, N1/eax, 4

#({tag 5:90}) [90->105] (level:0) is green with stack state #f
#({basic-block #() 105 110})
  lsr	N1/eax, N1/eax, 28
  ldb	N1/eax, {constant "Khigh_zeros_table"}, N1/eax
  add	eax, N0/edi, N1/eax

#() [105->110] (level:0) is green with stack state #f
#()
  rts-and-drop	0

+++ ending code for primitive_machine_word_count_high_zeros +++

+++ No Source Code Locators for primitive_machine_word_count_high_zeros +++


+++ Exported function definition primitive_type_check +++

+++ starting code for primitive_type_check +++

#() [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 #({tag 7:100}) 100 115}, {basic-block #({tag 1:70}) 65 70})
  move	N4/eax, eax
  load-stack-arg-n	#f, N1/NSPILL--1, 0
  move	G5/edi, N1/NSPILL--1
  beq	{tag 1:70}, G5/edi, {constant "KLobjectGVKd"}

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

#({tag 2:75}) [75->85] (level:0) is brown with stack state with
#({basic-block #() 25 45})
  move	N0/NSPILL-0, N4/eax
  move	G3/edi, G5/edi

#() [25->45] (level:0) is red with stack state with
#({basic-block #() 45 50})
  ld	N2/ebx, G3/edi, 4
  push	G3/edi
  move	eax, N0/NSPILL-0
  call	N2/ebx, 1

#() [45->50] (level:0) is red with stack state with
#({basic-block #() 50 65}, {basic-block #({tag 3:85}) 85 90})
  bne	{tag 3:85}, eax, {constant "KPfalseVKi"}

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 3:85}) 85 90})
  push	N1/NSPILL--1
  move	eax, N0/NSPILL-0
  call	{constant "Ktype_check_errorVKiI"}, 1

#({tag 3:85}) [85->90] (level:0) is yellow with stack state with
#({basic-block #({tag 4:95}) 90 95})
  move	N4/eax, N0/NSPILL-0

#({tag 4:95}) [90->95] (level:0) is green with stack state with
#({basic-block #({tag 4:95}, {tag 6:95}) 95 100})
  move	eax, N4/eax

#({tag 4:95}, {tag 6:95}) [95->100] (level:0) is #f with stack state #f
#({basic-block #({tag 1:70}, {tag 5:70}) 70 75})
  preserve-registers-exit	

#({tag 1:70}, {tag 5:70}) [70->75] (level:0) is green with stack state #f
#()
  rts-and-drop	4

#({tag 1:70}) [65->70] (level:0) is green with stack state before
#({basic-block #({tag 1:70}, {tag 5:70}) 70 75})
  move	eax, N4/eax

+++ ending code for primitive_type_check +++

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

+++ Live variable scopes for primitive_type_check +++
Start scope at 15 with frame for no variables
End scope at 50

+++ No Source Code Locators for primitive_type_check +++


+++ Exported function definition primitive_type_check_values +++

+++ starting code for primitive_type_check_values +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 35}, {basic-block #({tag 7:35}) 35 65})
  rem	"eliminated"
  load-stack-arg-n	#t, N1/edx, 0
  load-stack-arg-n	#t, N2/NSPILL--2, 1
  push	eax
  bmvset	{tag 7:35}

#() [30->35] (level:0) is red with stack state with
#({basic-block #({tag 8:65}) 65 100})
  push	1

#({tag 8:65}) [65->100] (level:0) is red with stack state with
#({basic-block #({tag 1:100}) 100 105})
  ld	N4/NSPILL-3, esp, 0
  add	N5/NSPILL-2, esp, 4
  add	N9/NSPILL-7, N1/edx, 8
  ld	N8/NSPILL-6, N1/edx, 4
  sub	N8/NSPILL-6, N8/NSPILL-6, 1
  move	N6/NSPILL-0, 0
  move	N10/NSPILL-4, 0

#({tag 1:100}) [100->105] (level:1) is green with stack state with
#({basic-block #() 105 110}, {basic-block #({tag 3:185}) 185 190})
  beq	{tag 3:185}, N10/NSPILL-4, N8/NSPILL-6

#() [105->110] (level:1) is green with stack state with
#({basic-block #() 110 125}, {basic-block #({tag 3:185}) 185 190})
  bge	{tag 3:185}, N10/NSPILL-4, N4/NSPILL-3

#() [110->125] (level:1) is green with stack state with
#({basic-block #() 125 135}, {basic-block #({tag 2:175}) 175 185})
  ld	N3/NSPILL-1, N5/NSPILL-2, N6/NSPILL-0
  ld	N7/NSPILL-5, N9/NSPILL-7, N10/NSPILL-4
  beq	{tag 2:175}, N7/NSPILL-5, {constant "KPfalseVKi"}

#() [125->135] (level:1) is green with stack state with
#({basic-block #() 135 155}, {basic-block #({tag 2:175}) 175 185})
  move	G14/edi, N7/NSPILL-5
  beq	{tag 2:175}, G14/edi, {constant "KLobjectGVKd"}

#() [135->155] (level:1) is red with stack state with
#({basic-block #() 155 160})
  ld	N13/ebx, G14/edi, 4
  push	G14/edi
  move	eax, N3/NSPILL-1
  call	N13/ebx, 1

#() [155->160] (level:1) is red with stack state with
#({basic-block #() 160 175}, {basic-block #({tag 2:175}) 175 185})
  bne	{tag 2:175}, eax, {constant "KPfalseVKi"}

#() [160->175] (level:1) is red with stack state with
#({basic-block #({tag 2:175}) 175 185})
  push	N7/NSPILL-5
  move	eax, N3/NSPILL-1
  call	{constant "Ktype_check_errorVKiI"}, 1

#({tag 2:175}) [175->185] (level:1) is green with stack state with
#({basic-block #({tag 1:100}) 100 105})
  add	N6/NSPILL-0, N6/NSPILL-0, 4
  add	N10/NSPILL-4, N10/NSPILL-4, 4

#() [330->335] (level:0) is #f with stack state #f
#()
  bra	{tag 1:100}

#({tag 7:35}) [35->65] (level:0) is red with stack state with
#({basic-block #({tag 8:65}) 65 100})
  ld-teb	N11/ecx, 32
  asl	N12/ebx, N11/ecx, 2
  sub	esp, esp, N12/ebx
  ld-teb-address	esi, 36
  copy-words-down-w	esp, esi, N11/ecx
  push	N12/ebx

#() [335->340] (level:0) is #f with stack state #f
#()
  bra	{tag 8:65}

#({tag 3:185}) [185->190] (level:1) is green with stack state with
#({basic-block #({tag 4:190}) 190 195}, {basic-block #({tag 6:255}) 255 265})
  beq	{tag 6:255}, N2/NSPILL--2, {constant "KPfalseVKi"}

#({tag 4:190}) [190->195] (level:2) is green with stack state with
#({basic-block #() 195 210}, {basic-block #({tag 6:255}) 255 265})
  bge	{tag 6:255}, N6/NSPILL-0, N4/NSPILL-3

#() [195->210] (level:2) is green with stack state with
#({basic-block #() 210 230}, {basic-block #({tag 5:250}) 250 255})
  ld	N3/NSPILL-1, N5/NSPILL-2, N6/NSPILL-0
  move	G16/edi, N2/NSPILL--2
  beq	{tag 5:250}, G16/edi, {constant "KLobjectGVKd"}

#() [210->230] (level:2) is red with stack state with
#({basic-block #() 230 235})
  ld	N15/ebx, G16/edi, 4
  push	G16/edi
  move	eax, N3/NSPILL-1
  call	N15/ebx, 1

#() [230->235] (level:2) is red with stack state with
#({basic-block #() 235 250}, {basic-block #({tag 5:250}) 250 255})
  bne	{tag 5:250}, eax, {constant "KPfalseVKi"}

#() [235->250] (level:2) is red with stack state with
#({basic-block #({tag 5:250}) 250 255})
  push	N2/NSPILL--2
  move	eax, N3/NSPILL-1
  call	{constant "Ktype_check_errorVKiI"}, 1

#({tag 5:250}) [250->255] (level:2) is green with stack state with
#({basic-block #({tag 4:190}) 190 195})
  add	N6/NSPILL-0, N6/NSPILL-0, 4

#() [340->345] (level:0) is #f with stack state #f
#()
  bra	{tag 4:190}

#({tag 6:255}) [255->265] (level:2) is red with stack state with
#({basic-block #() 265 270}, {basic-block #({tag 9:270}) 270 300})
  pop	N17/ebx
  bne	{tag 9:270}, N17/ebx, 1

#() [265->270] (level:2) is red with stack state with
#({basic-block #({tag 10:300}) 300 305})
  reset-values	

#({tag 10:300}) [300->305] (level:2) is red with stack state with
#({basic-block #({tag 11:310}) 310 315})
  pop	eax

#({tag 11:310}) [310->315] (level:0) is #f with stack state #f
#({basic-block #() 305 310})
  preserve-registers-exit	

#() [305->310] (level:2) is red with stack state #f
#()
  rts-and-drop	8

#({tag 9:270}) [270->300] (level:2) is red with stack state with
#({basic-block #({tag 10:300}) 300 305})
  asr	N19/edx, N17/ebx, 2
  st-teb	N19/edx, 32
  ld-teb-address	N18/edi, 36
  copy-words-down-w	N18/edi, esp, N19/edx
  add	esp, esp, N17/ebx
  set-values	

#() [345->350] (level:0) is #f with stack state #f
#()
  bra	{tag 10:300}

+++ ending code for primitive_type_check_values +++

+++ Frame sizes for primitive_type_check_values: GC: 0, NC: 8 +++

+++ Live variable scopes for primitive_type_check_values +++
Start scope at 3 with frame for no variables
End scope at 278

+++ No Source Code Locators for primitive_type_check_values +++


+++ Exported function definition primitive_type_check_rest_values +++

+++ starting code for primitive_type_check_rest_values +++

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

#({tag 9:200}) [200->215] (level:0) is #f with stack state #f
#({basic-block #() 5 25})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 30}, {basic-block #({tag 4:30}) 30 60})
  move	N0/edx, eax
  load-stack-arg-n	#t, N1/NSPILL--1, 0
  push	eax
  bmvset	{tag 4:30}

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

#({tag 5:60}) [60->75] (level:0) is red with stack state with
#({basic-block #({tag 1:75}) 75 80})
  ld	N3/NSPILL-3, esp, 0
  add	N4/NSPILL-2, esp, 4
  move	N5/NSPILL-0, N0/edx

#({tag 1:75}) [75->80] (level:1) is green with stack state with
#({basic-block #() 80 95}, {basic-block #({tag 3:140}) 140 150})
  bge	{tag 3:140}, N5/NSPILL-0, N3/NSPILL-3

#() [80->95] (level:1) is green with stack state with
#({basic-block #() 95 115}, {basic-block #({tag 2:135}) 135 140})
  ld	N2/NSPILL-1, N4/NSPILL-2, N5/NSPILL-0
  move	G9/edi, N1/NSPILL--1
  beq	{tag 2:135}, G9/edi, {constant "KLobjectGVKd"}

#() [95->115] (level:1) is red with stack state with
#({basic-block #() 115 120})
  ld	N8/ebx, G9/edi, 4
  push	G9/edi
  move	eax, N2/NSPILL-1
  call	N8/ebx, 1

#() [115->120] (level:1) is red with stack state with
#({basic-block #() 120 135}, {basic-block #({tag 2:135}) 135 140})
  bne	{tag 2:135}, eax, {constant "KPfalseVKi"}

#() [120->135] (level:1) is red with stack state with
#({basic-block #({tag 2:135}) 135 140})
  push	N1/NSPILL--1
  move	eax, N2/NSPILL-1
  call	{constant "Ktype_check_errorVKiI"}, 1

#({tag 2:135}) [135->140] (level:1) is green with stack state with
#({basic-block #({tag 1:75}) 75 80})
  add	N5/NSPILL-0, N5/NSPILL-0, 4

#() [215->220] (level:0) is #f with stack state #f
#()
  bra	{tag 1:75}

#({tag 4:30}) [30->60] (level:0) is red with stack state with
#({basic-block #({tag 5:60}) 60 75})
  ld-teb	N6/ecx, 32
  asl	N7/ebx, N6/ecx, 2
  sub	esp, esp, N7/ebx
  ld-teb-address	esi, 36
  copy-words-down-w	esp, esi, N6/ecx
  push	N7/ebx

#() [220->225] (level:0) is #f with stack state #f
#()
  bra	{tag 5:60}

#({tag 3:140}) [140->150] (level:1) is red with stack state with
#({basic-block #() 150 155}, {basic-block #({tag 6:155}) 155 185})
  pop	N10/ebx
  bne	{tag 6:155}, N10/ebx, 1

#() [150->155] (level:1) is red with stack state with
#({basic-block #({tag 7:185}) 185 190})
  reset-values	

#({tag 7:185}) [185->190] (level:1) is red with stack state with
#({basic-block #({tag 8:195}) 195 200})
  pop	eax

#({tag 8:195}) [195->200] (level:0) is #f with stack state #f
#({basic-block #() 190 195})
  preserve-registers-exit	

#() [190->195] (level:1) is red with stack state #f
#()
  rts-and-drop	4

#({tag 6:155}) [155->185] (level:1) is red with stack state with
#({basic-block #({tag 7:185}) 185 190})
  asr	N12/edx, N10/ebx, 2
  st-teb	N12/edx, 32
  ld-teb-address	N11/edi, 36
  copy-words-down-w	N11/edi, esp, N12/edx
  add	esp, esp, N10/ebx
  set-values	

#() [225->230] (level:0) is #f with stack state #f
#()
  bra	{tag 7:185}

+++ ending code for primitive_type_check_rest_values +++

+++ Frame sizes for primitive_type_check_rest_values: GC: 0, NC: 4 +++

+++ Live variable scopes for primitive_type_check_rest_values +++
Start scope at 3 with frame for no variables
End scope at 139

+++ No Source Code Locators for primitive_type_check_rest_values +++


+++ Exported function definition primitive_adjust_mv +++

+++ starting code for primitive_adjust_mv +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:45}) 45 55})
  bmvset	{tag 1:45}

#() [10->15] (level:0) is green with stack state #f
#({basic-block #() 15 25}, {basic-block #({tag 2:105}) 105 105})
  beq	{tag 2:105}, edi, 1

#() [15->25] (level:0) is green with stack state #f
#({basic-block #() 25 40}, {basic-block #({tag 3:40}) 40 45})
  st-teb	edi, 32
  beq	{tag 3:40}, edi, 0

#() [25->40] (level:0) is green with stack state #f
#({basic-block #({tag 3:40}) 40 45})
  ld-teb-address	N3/ebx, 36
  fill-words-w	N3/ebx, edi, {constant "KPfalseVKi"}
  st	eax, N3/ebx, 0

#({tag 3:40}) [40->45] (level:0) is green with stack state #f
#({basic-block #({tag 2:105}) 105 105})
  reset-values	

#({tag 2:105}) [105->105] (level:0) is green with stack state #f
#({basic-block #({tag 2:105}) 105 110})

#({tag 2:105}) [105->110] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:45}) [45->55] (level:0) is green with stack state #f
#({basic-block #() 55 60}, {basic-block #({tag 2:105}) 105 105})
  ld-teb	N0/ebx, 32
  beq	{tag 2:105}, edi, N0/ebx

#() [55->60] (level:0) is green with stack state #f
#({basic-block #() 60 70}, {basic-block #({tag 3:40}) 40 45})
  beq	{tag 3:40}, edi, 1

#() [60->70] (level:0) is green with stack state #f
#({basic-block #() 70 100}, {basic-block #({tag 4:100}) 100 105})
  st-teb	edi, 32
  blt	{tag 4:100}, edi, N0/ebx

#() [70->100] (level:0) is green with stack state #f
#({basic-block #({tag 4:100}) 100 105})
  sub	N1/ecx, edi, N0/ebx
  move	N2/edi, N0/ebx
  ld-teb-address	N3/ebx, 36
  asl	N2/edi, N2/edi, 2
  add	N2/edi, N2/edi, N3/ebx
  fill-words-w	N2/edi, N1/ecx, {constant "KPfalseVKi"}

#({tag 4:100}) [100->105] (level:0) is green with stack state #f
#({basic-block #({tag 2:105}) 105 105})
  set-values	

#() [110->115] (level:0) is #f with stack state #f
#()
  bra	{tag 2:105}

+++ ending code for primitive_adjust_mv +++

+++ No Source Code Locators for primitive_adjust_mv +++


+++ Exported function definition primitive_adjust_mv_rest +++

+++ starting code for primitive_adjust_mv_rest +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:40}) 40 50})
  bmvset	{tag 1:40}

#() [10->15] (level:0) is green with stack state #f
#({basic-block #() 15 35}, {basic-block #({tag 2:95}) 95 95})
  ble	{tag 2:95}, edi, 1

#() [15->35] (level:0) is green with stack state #f
#({basic-block #({tag 3:35}) 35 40})
  st-teb	edi, 32
  ld-teb-address	N3/edx, 36
  fill-words-w	N3/edx, edi, {constant "KPfalseVKi"}
  st	eax, N3/edx, 0

#({tag 3:35}) [35->40] (level:0) is green with stack state #f
#({basic-block #({tag 2:95}) 95 95})
  reset-values	

#({tag 2:95}) [95->95] (level:0) is green with stack state #f
#({basic-block #({tag 2:95}) 95 100})

#({tag 2:95}) [95->100] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:40}) [40->50] (level:0) is green with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 2:95}) 95 95})
  ld-teb	N0/ebx, 32
  ble	{tag 2:95}, edi, N0/ebx

#() [50->55] (level:0) is green with stack state #f
#({basic-block #() 55 85}, {basic-block #({tag 3:35}) 35 40})
  beq	{tag 3:35}, edi, 1

#() [55->85] (level:0) is green with stack state #f
#({basic-block #({tag 4:85}) 85 95})
  sub	N1/ecx, edi, N0/ebx
  move	N2/ebx, N0/ebx
  ld-teb-address	N3/edx, 36
  asl	N2/ebx, N2/ebx, 2
  add	N2/ebx, N2/ebx, N3/edx
  fill-words-w	N2/ebx, N1/ecx, {constant "KPfalseVKi"}

#({tag 4:85}) [85->95] (level:0) is green with stack state #f
#({basic-block #({tag 2:95}) 95 95})
  st-teb	edi, 32
  set-values	

#() [100->105] (level:0) is #f with stack state #f
#()
  bra	{tag 2:95}

+++ ending code for primitive_adjust_mv_rest +++

+++ No Source Code Locators for primitive_adjust_mv_rest +++


+++ Exported function definition primitive_pad_mv +++

+++ starting code for primitive_pad_mv +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 35})
  bmvset	{tag 1:25}

#() [10->15] (level:0) is green with stack state #f
#({basic-block #() 15 25}, {basic-block #({tag 2:70}) 70 70})
  ble	{tag 2:70}, edi, 1

#() [15->25] (level:0) is green with stack state #f
#({basic-block #({tag 2:70}) 70 70})
  ld-teb-address	N3/ebx, 36
  fill-words-w	N3/ebx, edi, {constant "KPfalseVKi"}

#({tag 2:70}) [70->70] (level:0) is green with stack state #f
#({basic-block #({tag 2:70}) 70 75})

#({tag 2:70}) [70->75] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:25}) [25->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 2:70}) 70 70})
  ld-teb	N0/ebx, 32
  beq	{tag 2:70}, edi, 1

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 70}, {basic-block #({tag 2:70}) 70 70})
  ble	{tag 2:70}, edi, N0/ebx

#() [40->70] (level:0) is green with stack state #f
#({basic-block #({tag 2:70}) 70 70})
  sub	N1/ecx, edi, N0/ebx
  move	N2/edi, N0/ebx
  ld-teb-address	N3/ebx, 36
  asl	N2/edi, N2/edi, 2
  add	N2/edi, N2/edi, N3/ebx
  fill-words-w	N2/edi, N1/ecx, {constant "KPfalseVKi"}

#() [75->80] (level:0) is #f with stack state #f
#()
  bra	{tag 2:70}

+++ ending code for primitive_pad_mv +++

+++ No Source Code Locators for primitive_pad_mv +++


+++ Exported function definition primitive_set_mv_from_vector +++

+++ starting code for primitive_set_mv_from_vector +++

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

#() [5->30] (level:0) is green with stack state #f
#({basic-block #({tag 1:30}) 30 40}, {basic-block #({tag 2:40}) 40 50})
  move	G0/ebx, ebx
  move	N3/eax, eax
  ld	N1/edx, N3/eax, 4
  asr	N1/edx, N1/edx, 2
  bne	{tag 2:40}, N1/edx, 1

#({tag 1:30}) [30->40] (level:0) is green with stack state #f
#({basic-block #({tag 4:90}) 85 90})
  ld	eax, N3/eax, 8
  reset-values	

#({tag 4:90}) [85->90] (level:0) is green with stack state #f
#({basic-block #({tag 4:90}) 90 95})
  move	ebx, G0/ebx

#({tag 4:90}) [90->95] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 2:40}) [40->50] (level:0) is green with stack state #f
#({basic-block #() 50 75}, {basic-block #({tag 3:75}) 75 85})
  st-teb	N1/edx, 32
  beq	{tag 3:75}, N1/edx, 0

#() [50->75] (level:0) is green with stack state #f
#({basic-block #({tag 4:90}) 85 90})
  add	esi, N3/eax, 8
  ld	eax, esi, 0
  ld-teb-address	N2/edi, 36
  copy-words-down-w	N2/edi, esi, N1/edx
  set-values	

#() [95->100] (level:0) is #f with stack state #f
#()
  bra	{tag 4:90}

#({tag 3:75}) [75->85] (level:0) is green with stack state #f
#({basic-block #({tag 4:90}) 85 90})
  move	eax, {constant "KPfalseVKi"}
  set-values	

#() [100->105] (level:0) is #f with stack state #f
#()
  bra	{tag 4:90}

+++ ending code for primitive_set_mv_from_vector +++

+++ No Source Code Locators for primitive_set_mv_from_vector +++


+++ Exported function definition primitive_build_bind_exit_frame +++

+++ starting code for primitive_build_bind_exit_frame +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 45})
  pop	esi
  sub	esp, esp, 56
  st	eax, esp, 52
  ld-teb	eax, 0
  st	ebp, esp, 48
  st	eax, esp, 44
  move	eax, esp

#() [40->45] (level:0) is #f with stack state #f
#()
  jmp	esi, 0, 0, #f, #f

+++ ending code for primitive_build_bind_exit_frame +++

+++ No Source Code Locators for primitive_build_bind_exit_frame +++


+++ Exported function definition primitive_build_unwind_protect_frame +++

+++ starting code for primitive_build_unwind_protect_frame +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50})
  pop	N0/edi
  sub	esp, esp, 12
  st	eax, esp, 8
  ld-teb	eax, 0
  st	ebp, esp, 4
  st	eax, esp, 0
  move	eax, esp
  st-teb	esp, 0

#() [45->50] (level:0) is #f with stack state #f
#()
  jmp	N0/edi, 0, 0, #f, #f

+++ ending code for primitive_build_unwind_protect_frame +++

+++ No Source Code Locators for primitive_build_unwind_protect_frame +++


+++ Exported function definition primitive_unwind_protect_cleanup +++

+++ starting code for primitive_unwind_protect_cleanup +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 1:35}) 35 65})
  ld-teb	N1/ebx, 0
  ld	N0/edi, N1/ebx, 0
  st-teb	N0/edi, 0
  push	eax
  bmvset	{tag 1:35}

#() [30->35] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 80})
  push	1

#({tag 2:65}) [65->80] (level:0) is #f with stack state #f
#({basic-block #() 80 95})
  push	N1/ebx
  ld	N0/edi, N1/ebx, 8
  call	N0/edi, 0

#() [80->95] (level:0) is #f with stack state #f
#({basic-block #() 95 100}, {basic-block #({tag 3:100}) 100 130})
  pop	N1/ebx
  pop	N4/edx
  bne	{tag 3:100}, N4/edx, 1

#() [95->100] (level:0) is #f with stack state #f
#({basic-block #({tag 4:130}) 130 145})
  reset-values	

#({tag 4:130}) [130->145] (level:0) is #f with stack state #f
#({basic-block #() 145 150})
  pop	eax
  ld	esi, esp, 0
  add	esp, N1/ebx, 12

#() [145->150] (level:0) is #f with stack state #f
#()
  jmp	esi, 0, 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 80})
  ld-teb	N2/ecx, 32
  asl	N3/edx, N2/ecx, 2
  sub	esp, esp, N3/edx
  ld-teb-address	esi, 36
  copy-words-down-w	esp, esi, N2/ecx
  push	N3/edx

#() [150->155] (level:0) is #f with stack state #f
#()
  bra	{tag 2:65}

#({tag 3:100}) [100->130] (level:0) is #f with stack state #f
#({basic-block #({tag 4:130}) 130 145})
  asr	N6/eax, N4/edx, 2
  st-teb	N6/eax, 32
  ld-teb-address	N5/edi, 36
  copy-words-down-w	N5/edi, esp, N6/eax
  add	esp, esp, N4/edx
  set-values	

#() [155->160] (level:0) is #f with stack state #f
#()
  bra	{tag 4:130}

+++ ending code for primitive_unwind_protect_cleanup +++

+++ No Source Code Locators for primitive_unwind_protect_cleanup +++


+++ Exported function definition primitive_nlx +++

+++ starting code for primitive_nlx +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 50}, {basic-block #({tag 1:55}) 55 65})
  ld-teb	N1/edx, 0
  ld	N0/ecx, eax, 44
  move	N2/ebx, eax
  load-stack-arg-n	#t, N3/edi, 0
  bne	{tag 1:55}, N1/edx, N0/ecx

#() [30->50] (level:0) is #f with stack state #f
#({basic-block #() 50 55})
  move	eax, N3/edi
  ld	N4/edi, N2/ebx, 52
  ld	ebp, N2/ebx, 48
  add	esp, N2/ebx, 56

#() [50->55] (level:0) is #f with stack state #f
#()
  jmp	N4/edi, 1, 0, #f, #f

#({tag 1:55}) [55->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 2:75}) 75 85})
  add	N5/eax, N2/ebx, 4
  bmvset	{tag 2:75}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 3:165}) 165 170})
  st	N3/edi, N5/eax, 8
  st	5, N5/eax, 4

#({tag 3:165}) [165->170] (level:0) is #f with stack state #f
#({basic-block #({tag 5:170}) 170 175})
  st	N5/eax, N2/ebx, 0

#({tag 5:170}) [170->175] (level:1) is #f with stack state #f
#({basic-block #() 175 210}, {basic-block #({tag 6:330}) 330 330})
  beq	{tag 6:330}, N1/edx, 0

#() [175->210] (level:1) is #f with stack state #f
#({basic-block #() 210 230})
  move	esp, N1/edx
  ld	N9/edi, esp, 0
  ld	N10/eax, esp, 8
  st-teb	N9/edi, 0
  ld	ebp, esp, 4
  push	N2/ebx
  call	N10/eax, 0

#() [210->230] (level:1) is #f with stack state #f
#({basic-block #() 230 255}, {basic-block #({tag 5:170}) 170 175})
  pop	N2/ebx
  ld-teb	N1/edx, 0
  ld	N11/edi, N2/ebx, 44
  bne	{tag 5:170}, N11/edi, N1/edx

#() [230->255] (level:0) is #f with stack state #f
#({basic-block #({tag 7:255}) 255 265}, {basic-block #({tag 8:265}) 265 275})
  ld	G12/eax, N2/ebx, 0
  move	N15/eax, G12/eax
  ld	N13/edx, N15/eax, 4
  asr	N13/edx, N13/edx, 2
  bne	{tag 8:265}, N13/edx, 1

#({tag 7:255}) [255->265] (level:0) is #f with stack state #f
#({basic-block #({tag 10:310}) 310 325})
  ld	eax, N15/eax, 8
  reset-values	

#({tag 10:310}) [310->325] (level:0) is #f with stack state #f
#({basic-block #() 325 330})
  ld	N16/edi, N2/ebx, 52
  ld	ebp, N2/ebx, 48
  add	esp, N2/ebx, 56

#() [325->330] (level:0) is #f with stack state #f
#()
  jmp	N16/edi, 1, 0, #f, #f

#({tag 2:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #() 85 110}, {basic-block #({tag 4:135}) 135 165})
  ld-teb	ecx, 32
  ble	{tag 4:135}, ecx, 8

#() [85->110] (level:0) is #f with stack state #f
#({basic-block #() 110 135})
  push	ecx
  push	N2/ebx
  push	N1/edx
  move	eax, ecx
  call	{constant "primitive_allocate_vector"}, 1

#() [110->135] (level:0) is #f with stack state #f
#({basic-block #({tag 4:135}) 135 165})
  move	G6/eax, eax
  pop	N1/edx
  pop	N2/ebx
  pop	ecx
  move	N5/eax, G6/eax

#({tag 4:135}) [135->165] (level:0) is #f with stack state #f
#({basic-block #({tag 3:165}) 165 170})
  asl	N8/edi, ecx, 2
  add	N8/edi, N8/edi, 1
  st	N8/edi, N5/eax, 4
  add	N7/edi, N5/eax, 8
  ld-teb-address	esi, 36
  copy-words-down-w	N7/edi, esi, ecx

#() [335->340] (level:0) is #f with stack state #f
#()
  bra	{tag 3:165}

#({tag 6:330}) [330->330] (level:1) is #f with stack state #f
#({basic-block #({tag 6:330}) 330 335})

#({tag 8:265}) [265->275] (level:0) is #f with stack state #f
#({basic-block #() 275 300}, {basic-block #({tag 9:300}) 300 310})
  st-teb	N13/edx, 32
  beq	{tag 9:300}, N13/edx, 0

#() [275->300] (level:0) is #f with stack state #f
#({basic-block #({tag 10:310}) 310 325})
  add	esi, N15/eax, 8
  ld	eax, esi, 0
  ld-teb-address	N14/edi, 36
  copy-words-down-w	N14/edi, esi, N13/edx
  set-values	

#() [340->345] (level:0) is #f with stack state #f
#()
  bra	{tag 10:310}

#({tag 6:330}) [330->335] (level:1) is #f with stack state #f
#()
  jmp	{constant "primitive_error"}, 0, 0, #f, #f

#({tag 9:300}) [300->310] (level:0) is #f with stack state #f
#({basic-block #({tag 10:310}) 310 325})
  move	eax, {constant "KPfalseVKi"}
  set-values	

#() [345->350] (level:0) is #f with stack state #f
#()
  bra	{tag 10:310}

+++ ending code for primitive_nlx +++

+++ No Source Code Locators for primitive_nlx +++


+++ Exported function definition primitive_stack_allocate_vector +++

+++ starting code for primitive_stack_allocate_vector +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  pop	N0/edx
  move	N1/edi, eax
  asl	N3/ebx, N1/edi, 2
  add	N3/ebx, N3/ebx, 8
  sub	esp, esp, N3/ebx
  move	N2/eax, esp
  asl	N4/edi, N1/edi, 2
  add	N4/edi, N4/edi, 1
  st	N4/edi, N2/eax, 4
  st	{constant "KLsimple_object_vectorGVKdW"}, N2/eax, 0
  move	eax, N2/eax

#() [60->65] (level:0) is #f with stack state #f
#()
  jmp	N0/edx, 0, 0, #f, #f

+++ ending code for primitive_stack_allocate_vector +++

+++ No Source Code Locators for primitive_stack_allocate_vector +++


+++ Exported function definition primitive_stack_allocate_vector_from_buffer +++

+++ starting code for primitive_stack_allocate_vector_from_buffer +++

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

#() [5->95] (level:0) is #f with stack state #f
#({basic-block #() 95 100})
  ld	esi, esp, 4
  pop	N0/edx
  add	esp, esp, 4
  move	N1/ebx, eax
  asl	N3/edi, N1/ebx, 2
  add	N3/edi, N3/edi, 8
  sub	esp, esp, N3/edi
  move	N2/eax, esp
  asl	N4/edi, N1/ebx, 2
  add	N4/edi, N4/edi, 1
  st	N4/edi, N2/eax, 4
  st	{constant "KLsimple_object_vectorGVKdW"}, N2/eax, 0
  add	N5/edi, N2/eax, 8
  move	ecx, N1/ebx
  move	edi, N5/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	eax, N2/eax

#() [95->100] (level:0) is #f with stack state #f
#()
  jmp	N0/edx, 0, 0, #f, #f

+++ ending code for primitive_stack_allocate_vector_from_buffer +++

+++ No Source Code Locators for primitive_stack_allocate_vector_from_buffer +++


+++ Exported function definition primitive_stack_allocate_vector_from_buffer_with_offset +++

+++ starting code for primitive_stack_allocate_vector_from_buffer_with_offset +++

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

#() [5->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  ld	esi, esp, 4
  ld	N0/edi, esp, 8
  asl	N0/edi, N0/edi, 2
  add	esi, esi, N0/edi
  pop	N1/edx
  add	esp, esp, 8
  move	N2/ebx, eax
  asl	N4/edi, N2/ebx, 2
  add	N4/edi, N4/edi, 8
  sub	esp, esp, N4/edi
  move	N3/eax, esp
  asl	N5/edi, N2/ebx, 2
  add	N5/edi, N5/edi, 1
  st	N5/edi, N3/eax, 4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/eax, 0
  add	N6/edi, N3/eax, 8
  move	ecx, N2/ebx
  move	edi, N6/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	eax, N3/eax

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, 0, 0, #f, #f

+++ ending code for primitive_stack_allocate_vector_from_buffer_with_offset +++

+++ No Source Code Locators for primitive_stack_allocate_vector_from_buffer_with_offset +++


+++ Exported function definition primitive_heap_vector_remaining_values +++

+++ starting code for primitive_heap_vector_remaining_values +++

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

#() [5->15] (level:0) is green with stack state before
#({basic-block #() 15 20}, {basic-block #({tag 1:35}) 35 45})
  ld-teb-address	esi, 36
  bmvset	{tag 1:35}

#() [15->20] (level:0) is green with stack state before
#({basic-block #() 20 30}, {basic-block #({tag 3:30}) 30 35})
  bne	{tag 3:30}, edi, 0

#() [20->30] (level:0) is green with stack state before
#({basic-block #({tag 2:75}) 75 90})
  st	eax, esi, 0
  move	eax, 1

#({tag 2:75}) [75->90] (level:0) is green with stack state before
#({basic-block #() 90 95}, {basic-block #({tag 12:180}) 180 195})
  move	N6/edi, esi
  move	N5/eax, eax
  bne	{tag 12:180}, N5/eax, 0

#() [90->95] (level:0) is green with stack state before
#({basic-block #({tag 5:150}) 145 150})
  move	G7/eax, {constant "KPempty_vectorVKi"}

#({tag 5:150}) [145->150] (level:0) is green with stack state before
#({basic-block #({tag 5:150}, {tag 10:150}) 150 155})
  move	eax, G7/eax

#({tag 5:150}, {tag 10:150}) [150->155] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:35}) [35->45] (level:0) is green with stack state before
#({basic-block #() 45 50}, {basic-block #({tag 3:30}) 30 35})
  ld-teb	N2/ebx, 32
  bge	{tag 3:30}, edi, N2/ebx

#() [45->50] (level:0) is green with stack state before
#({basic-block #() 50 55}, {basic-block #({tag 4:55}) 55 75})
  bne	{tag 4:55}, edi, 0

#() [50->55] (level:0) is green with stack state before
#({basic-block #({tag 4:55}) 55 75})
  st	eax, esi, 0

#({tag 4:55}) [55->75] (level:0) is green with stack state before
#({basic-block #({tag 2:75}) 75 90})
  sub	N2/ebx, N2/ebx, edi
  asl	edi, edi, 2
  add	esi, esi, edi
  move	eax, N2/ebx

#() [195->200] (level:0) is #f with stack state #f
#()
  bra	{tag 2:75}

#({tag 3:30}) [30->35] (level:0) is green with stack state before
#({basic-block #({tag 2:75}) 75 90})
  move	eax, 0

#() [200->205] (level:0) is #f with stack state #f
#()
  bra	{tag 2:75}

#({tag 12:180}) [180->195] (level:0) is #f with stack state #f
#({basic-block #({tag 7:155}) 155 165})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 7:155}) [155->165] (level:0) is brown with stack state with
#({basic-block #({tag 6:95}) 95 135})
  move	N0/eax, N5/eax
  move	N1/ebx, N6/edi

#({tag 6:95}) [95->135] (level:0) is red with stack state with
#({basic-block #() 135 145})
  asl	N4/edi, N0/eax, 2
  add	N4/edi, N4/edi, 8
  push	N1/ebx
  push	1
  push	N0/eax
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N4/edi
  call-alien	{constant "primitive_alloc_rt"}, 0

#() [135->145] (level:0) is red with stack state with
#({basic-block #({tag 8:175}) 165 170})
  add	esp, esp, 20
  move	G3/eax, eax

#({tag 8:175}) [165->170] (level:0) is yellow with stack state with
#({basic-block #({tag 8:175}, {tag 9:175}) 170 175})
  move	G7/eax, G3/eax

#({tag 8:175}, {tag 9:175}) [170->175] (level:0) is green with stack state with
#({basic-block #({tag 9:175}, {tag 8:175}, {tag 11:175}) 175 180})
  move	eax, G7/eax

#({tag 9:175}, {tag 8:175}, {tag 11:175}) [175->180] (level:0) is #f with stack state #f
#({basic-block #({tag 5:150}, {tag 10:150}) 150 155})
  preserve-registers-exit	

#() [205->210] (level:0) is #f with stack state #f
#()
  bra	{tag 5:150}

+++ ending code for primitive_heap_vector_remaining_values +++

+++ Live variable scopes for primitive_heap_vector_remaining_values +++
Start scope at 81 with frame for no variables
End scope at 109

+++ No Source Code Locators for primitive_heap_vector_remaining_values +++


+++ Exported function definition primitive_stack_vector_remaining_values +++

+++ starting code for primitive_stack_vector_remaining_values +++

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

#() [5->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20}, {basic-block #({tag 1:35}) 35 45})
  ld-teb-address	esi, 36
  bmvset	{tag 1:35}

#() [15->20] (level:0) is #f with stack state #f
#({basic-block #() 20 30}, {basic-block #({tag 3:30}) 30 35})
  bne	{tag 3:30}, edi, 0

#() [20->30] (level:0) is #f with stack state #f
#({basic-block #({tag 2:75}) 75 155})
  st	eax, esi, 0
  move	eax, 1

#({tag 2:75}) [75->155] (level:0) is #f with stack state #f
#({basic-block #() 155 160})
  pop	N1/edx
  move	N2/ebx, eax
  asl	N4/edi, N2/ebx, 2
  add	N4/edi, N4/edi, 8
  sub	esp, esp, N4/edi
  move	N3/eax, esp
  asl	N5/edi, N2/ebx, 2
  add	N5/edi, N5/edi, 1
  st	N5/edi, N3/eax, 4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/eax, 0
  add	N6/edi, N3/eax, 8
  move	ecx, N2/ebx
  move	edi, N6/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	eax, N3/eax

#() [155->160] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, 0, 0, #f, #f

#({tag 1:35}) [35->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 3:30}) 30 35})
  ld-teb	N0/ebx, 32
  bge	{tag 3:30}, edi, N0/ebx

#() [45->50] (level:0) is #f with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 4:55}) 55 75})
  bne	{tag 4:55}, edi, 0

#() [50->55] (level:0) is #f with stack state #f
#({basic-block #({tag 4:55}) 55 75})
  st	eax, esi, 0

#({tag 4:55}) [55->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:75}) 75 155})
  sub	N0/ebx, N0/ebx, edi
  asl	edi, edi, 2
  add	esi, esi, edi
  move	eax, N0/ebx

#() [160->165] (level:0) is #f with stack state #f
#()
  bra	{tag 2:75}

#({tag 3:30}) [30->35] (level:0) is #f with stack state #f
#({basic-block #({tag 2:75}) 75 155})
  move	eax, 0

#() [165->170] (level:0) is #f with stack state #f
#()
  bra	{tag 2:75}

+++ ending code for primitive_stack_vector_remaining_values +++

+++ No Source Code Locators for primitive_stack_vector_remaining_values +++


+++ Exported function definition primitive_mep_apply +++

+++ starting code for primitive_mep_apply +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 1:250}) 250 275})
  move	ebx, eax
  load-stack-arg-n	#t, N0/edx, 0
  load-stack-arg-n	#t, N1/eax, 1
  move	N2/eax, N1/eax
  ld	ecx, N2/eax, 4
  asr	ecx, ecx, 2
  add	eax, N2/eax, 8
  ld	N3/edi, ebx, 8
  ld	N3/edi, N3/edi, 4
  and	N3/edi, N3/edi, 1310720
  bne	{tag 1:250}, N3/edi, 0

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70}, {basic-block #({tag 3:80}) 80 90})
  beq	{tag 3:80}, ecx, 0

#() [65->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 110})
  beq	{tag 4:95}, ecx, 1

#() [70->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80}, {basic-block #({tag 5:115}) 115 140})
  beq	{tag 5:115}, ecx, 2

#() [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 2:180}) 180 245}, {basic-block #({tag 6:145}) 145 175})
  beq	{tag 6:145}, ecx, 3

#({tag 2:180}) [180->245] (level:0) is #f with stack state #f
#({basic-block #() 245 250})
  sub	ecx, ecx, 1
  pop	esi
  add	esp, esp, 8
  asl	N5/edi, ecx, 2
  sub	esp, esp, N5/edi
  move	N4/edi, esp
  push	esi
  add	eax, eax, 4
  move	edi, N4/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  move	edi, N0/edx
  ld	eax, eax, -4

#() [245->250] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 1:250}) [250->275] (level:0) is #f with stack state #f
#({basic-block #() 275 535}, {basic-block #({tag 7:540}) 540 560})
  ld	N6/edi, ebx, 8
  ld	N6/edi, N6/edi, 4
  asr	N6/edi, N6/edi, 2
  and	N6/edi, N6/edi, 255
  beq	{tag 7:540}, N6/edi, 0

#() [275->535] (level:0) is #f with stack state #f
#({basic-block #() 535 540})
  pop	N7/edi
  add	esp, esp, 4
  st	N0/edx, esp, 0
  asl	esi, ecx, 2
  sub	esp, esp, esi
  push	N7/edi
  add	N9/edi, esp, 4
  push	ecx
  move	edi, N9/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  pop	ecx
  ld	eax, esp, 4
  move-return-address	#f, 4, #f
  ld	N14/edi, ebx, 8
  ld	N14/edi, N14/edi, 4
  asr	N14/edi, N14/edi, 2
  and	N14/edi, N14/edi, 255
  move	esi, esp
  sub	esp, esp, 16
  move	N13/edx, ecx
  move	ecx, N14/edi
  move	N15/edi, esp
  move	edi, N15/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N12/edi, esi
  asl	N13/edx, N13/edx, 2
  move	ecx, N13/edx
  ld	esi, ebx, 8
  ld	esi, esi, 4
  and	esi, esi, 1020
  sub	N13/edx, N13/edx, esi
  add	N13/edx, N13/edx, 1
  st	N13/edx, N12/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N12/edi, -8
  add	ecx, ecx, 12
  st	ecx, N12/edi, -12
  add	N16/edx, N12/edi, -8
  st	N16/edx, N12/edi, -16
  ld	N17/edi, ebx, 8
  ld	N17/edi, N17/edi, 4
  asr	N17/edi, N17/edi, 2
  and	N17/edi, N17/edi, 255
  asl	N17/edi, N17/edi, 2
  add	N18/edi, esp, N17/edi
  add	N18/edi, N18/edi, 4
  ld	N19/edx, N18/edi, 0
  add	N19/edx, N19/edx, 4
  st	N19/edx, N18/edi, 0
  ld	N0/edx, esp, N19/edx
  move	edi, N0/edx

#() [535->540] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 3:80}) [80->90] (level:0) is #f with stack state #f
#({basic-block #() 90 95})
  move-return-address	#f, 8, #f
  move	edi, N0/edx

#() [90->95] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 4:95}) [95->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  move-return-address	#f, 8, #f
  move	edi, N0/edx
  ld	eax, eax, 0

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:115}) [115->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 1
  move-return-address	#f, 4, #f
  move	edi, N0/edx
  ld	eax, eax, 0

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 6:145}) [145->175] (level:0) is #f with stack state #f
#({basic-block #() 175 180})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 0
  ld	esi, eax, 8
  store-stack-arg-n	esi, 1
  move	edi, N0/edx
  ld	eax, eax, 0

#() [175->180] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 7:540}) [540->560] (level:0) is #f with stack state #f
#({basic-block #() 560 565})
  sub	eax, eax, 8
  store-stack-arg-n	4, 1
  move-return-address	#f, 4, #f
  move	edi, N0/edx

#() [560->565] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for primitive_mep_apply +++

+++ No Source Code Locators for primitive_mep_apply +++


+++ Exported function definition primitive_mep_apply_with_optionals +++

+++ starting code for primitive_mep_apply_with_optionals +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 1:250}) 250 255})
  move	ebx, eax
  load-stack-arg-n	#t, N0/edx, 0
  load-stack-arg-n	#t, N1/eax, 1
  move	N2/eax, N1/eax
  ld	ecx, N2/eax, 4
  asr	ecx, ecx, 2
  add	eax, N2/eax, 8
  ld	N3/edi, ebx, 8
  ld	N3/edi, N3/edi, 4
  and	N3/edi, N3/edi, 1310720
  bne	{tag 1:250}, N3/edi, 0

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70}, {basic-block #({tag 3:80}) 80 90})
  beq	{tag 3:80}, ecx, 0

#() [65->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 110})
  beq	{tag 4:95}, ecx, 1

#() [70->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80}, {basic-block #({tag 5:115}) 115 140})
  beq	{tag 5:115}, ecx, 2

#() [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 2:180}) 180 245}, {basic-block #({tag 6:145}) 145 175})
  beq	{tag 6:145}, ecx, 3

#({tag 2:180}) [180->245] (level:0) is #f with stack state #f
#({basic-block #() 245 250})
  sub	ecx, ecx, 1
  pop	esi
  add	esp, esp, 8
  asl	N5/edi, ecx, 2
  sub	esp, esp, N5/edi
  move	N4/edi, esp
  push	esi
  add	eax, eax, 4
  move	edi, N4/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  move	edi, N0/edx
  ld	eax, eax, -4

#() [245->250] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 1:250}) [250->255] (level:0) is #f with stack state #f
#({basic-block #() 255 260}, {basic-block #({tag 8:260}) 260 280})
  beq	{tag 8:260}, ecx, 1

#() [255->260] (level:0) is #f with stack state #f
#({basic-block #({tag 7:315}) 315 390}, {basic-block #({tag 9:285}) 285 310})
  beq	{tag 9:285}, ecx, 2

#({tag 7:315}) [315->390] (level:0) is #f with stack state #f
#({basic-block #() 390 395})
  asl	N7/edi, ecx, 2
  store-stack-arg-n	N7/edi, 1
  pop	esi
  sub	ecx, ecx, 1
  add	esp, esp, 4
  asl	N8/edi, ecx, 2
  sub	esp, esp, N8/edi
  move	N6/edi, esp
  push	esi
  add	eax, eax, 4
  move	edi, N6/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  move	edi, N0/edx
  ld	eax, eax, -4

#() [390->395] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 3:80}) [80->90] (level:0) is #f with stack state #f
#({basic-block #() 90 95})
  move-return-address	#f, 8, #f
  move	edi, N0/edx

#() [90->95] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 4:95}) [95->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  move-return-address	#f, 8, #f
  move	edi, N0/edx
  ld	eax, eax, 0

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:115}) [115->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 1
  move-return-address	#f, 4, #f
  move	edi, N0/edx
  ld	eax, eax, 0

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 6:145}) [145->175] (level:0) is #f with stack state #f
#({basic-block #() 175 180})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 0
  ld	esi, eax, 8
  store-stack-arg-n	esi, 1
  move	edi, N0/edx
  ld	eax, eax, 0

#() [175->180] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 8:260}) [260->280] (level:0) is #f with stack state #f
#({basic-block #() 280 285})
  store-stack-arg-n	4, 1
  move-return-address	#f, 4, #f
  move	edi, N0/edx
  ld	eax, eax, 0

#() [280->285] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 9:285}) [285->310] (level:0) is #f with stack state #f
#({basic-block #() 310 315})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 0
  store-stack-arg-n	8, 1
  move	edi, N0/edx
  ld	eax, eax, 0

#() [310->315] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for primitive_mep_apply_with_optionals +++

+++ No Source Code Locators for primitive_mep_apply_with_optionals +++


+++ Exported function definition primitive_apply +++

+++ starting code for primitive_apply +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 2:35}) 35 50})
  move	ebx, eax
  ld	G6/edx, esp, 4
  ld	N0/ecx, G6/edx, 4
  asr	N0/ecx, N0/ecx, 2
  beq	{tag 2:35}, N0/ecx, 1

#() [30->35] (level:0) is #f with stack state #f
#({basic-block #({tag 1:75}) 75 155}, {basic-block #({tag 3:55}) 55 70})
  beq	{tag 3:55}, N0/ecx, 2

#({tag 1:75}) [75->155] (level:0) is #f with stack state #f
#({basic-block #() 155 160})
  pop	N3/edi
  asl	N2/eax, N0/ecx, 2
  sub	esp, esp, N2/eax
  sub	N1/eax, N0/ecx, 1
  add	esp, esp, 8
  push	N3/edi
  add	N5/edi, esp, 4
  add	N4/ecx, G6/edx, 12
  move	edi, N5/edi
  move	esi, N4/ecx
  copy-words-down-w	edi, esi, N1/eax
  ld	N0/ecx, G6/edx, 4
  asr	N0/ecx, N0/ecx, 2
  move	ecx, N0/ecx
  add	G6/edx, G6/edx, 8
  ld	eax, G6/edx, 0

#() [155->160] (level:0) is #f with stack state #f
#()
  jmp	{constant "apply_xep"}, #[1, #"function", #"arg-count"], 0, #f, #f

#({tag 2:35}) [35->50] (level:0) is #f with stack state #f
#({basic-block #() 50 55})
  ld	eax, G6/edx, 8
  pop	esi
  st	esi, esp, 0

#() [50->55] (level:0) is #f with stack state #f
#()
  jmp	{constant "apply_xep_0"}, #[1, #"function"], 0, #f, #f

#({tag 3:55}) [55->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  ld	eax, G6/edx, 8
  ld	esi, G6/edx, 12
  st	esi, esp, 4

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	{constant "apply_xep_1"}, #[1, #"function"], 0, #f, #f

+++ ending code for primitive_apply +++

+++ No Source Code Locators for primitive_apply +++


+++ Exported function definition primitive_remove_optionals +++

+++ starting code for primitive_remove_optionals +++

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

#() [5->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  push	ecx
  push	edi
  add	N0/edx, esi, 12
  ld	N1/edx, esp, N0/edx
  sub	N2/edi, esi, 4
  sub	N1/edx, N1/edx, N2/edi
  move	N4/ecx, esi
  add	esi, esp, 12
  add	N3/edi, esi, N1/edx
  copy-words-up	N3/edi, esi, N4/ecx
  pop	edi
  pop	ecx

#() [65->70] (level:0) is #f with stack state #f
#()
  rts-and-drop	N1/edx

+++ ending code for primitive_remove_optionals +++

+++ No Source Code Locators for primitive_remove_optionals +++


+++ Exported function definition primitive_exit_application +++

+++ starting code for primitive_exit_application +++

#() [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 15})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->15] (level:0) is red with stack state with
#({basic-block #() 15 20})
  push	eax
  call-alien	{constant "exit"}, 0

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

#({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_exit_application +++

+++ Live variable scopes for primitive_exit_application +++
Start scope at 3 with frame for no variables
End scope at 12

+++ No Source Code Locators for primitive_exit_application +++


+++ Exported function definition make_foreign_thread_internal +++

+++ starting code for make_foreign_thread_internal +++

#() [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	{constant "Kmake_foreign_threadYthreads_primitivesVdylanI"}, 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 make_foreign_thread_internal +++

+++ Live variable scopes for make_foreign_thread_internal +++
Start scope at 7 with frame for no variables
End scope at 11

+++ No Source Code Locators for make_foreign_thread_internal +++


+++ Exported function definition primitive_ensure_valid_teb +++

+++ starting code for primitive_ensure_valid_teb +++

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

#({tag 13:390}) [390->405] (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 30})
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_get_value"}, 0

#() [15->30] (level:0) is red with stack state with
#({basic-block #() 30 40}, {basic-block #({tag 1:320}) 320 330})
  add	esp, esp, 4
  move	N0/NSPILL-0, eax
  bne	{tag 1:320}, N0/NSPILL-0, 0

#() [30->40] (level:0) is red with stack state with
#({basic-block #() 40 80})
  push	336
  call-alien	{constant "dylan__malloc__misc"}, 0

#() [40->80] (level:0) is red with stack state with
#({basic-block #() 80 85})
  add	esp, esp, 4
  move	N1/edi, eax
  add	N2/NSPILL-1, N1/edi, 12
  add	N3/ebx, N2/NSPILL-1, 324
  push	N3/ebx
  push	N1/edi
  push	N1/edi
  call-alien	{constant "MMRegisterRootAmbig"}, 0

#() [80->85] (level:0) is red with stack state with
#({basic-block #({tag 8:350}) 350 355})
  add	esp, esp, 12

#({tag 8:350}) [350->355] (level:1) is green with stack state with
#({basic-block #({tag 9:90}) 90 95}, {basic-block #({tag 8:350}) 350 355})
  conditional-move	{tag 8:350}, {indirect-constant "Pruntime_spin_lock"}, 1, 0

#({tag 9:90}) [90->95] (level:0) is red with stack state with
#({basic-block #() 95 100}, {basic-block #({tag 2:100}) 100 170})
  beq	{tag 2:100}, {indirect-constant "Pteb_chain"}, 0

#() [95->100] (level:0) is red with stack state with
#({basic-block #({tag 2:100}) 100 170})
  st	N1/edi, {indirect-constant "Pteb_chain"}, 8

#({tag 2:100}) [100->170] (level:0) is red with stack state with
#({basic-block #() 170 185})
  st	{indirect-constant "Pteb_chain"}, N1/edi, 4
  st	0, N1/edi, 8
  move	{indirect-constant "Pteb_chain"}, N1/edi
  move	{indirect-constant "Pruntime_spin_lock"}, 0
  add	N0/NSPILL-0, N2/NSPILL-1, 32
  st	0, N2/NSPILL-1, 0
  st	0, N2/NSPILL-1, 4
  st	0, N0/NSPILL-0, 0
  st	{constant "KPempty_listVKi"}, N0/NSPILL-0, 16
  st	{constant "KPunboundVKi"}, N0/NSPILL-0, 4
  set-teb	N0/NSPILL-0
  push	N0/NSPILL-0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [170->185] (level:0) is red with stack state with
#({basic-block #() 185 210})
  add	esp, esp, 8
  st	0, N0/NSPILL-0, 20
  call-alien	{constant "getpagesize"}, 0

#() [185->210] (level:0) is red with stack state with
#({basic-block #() 210 220})
  sub	N4/eax, eax, 1
  or	N4/eax, N4/eax, esp
  add	N4/eax, N4/eax, 1
  push	N4/eax
  call-alien	{constant "dylan_mm_register_thread"}, 0

#() [210->220] (level:0) is red with stack state with
#({basic-block #() 220 235}, {basic-block #({tag 6:335}) 335 350})
  add	esp, esp, 4
  beq	{tag 6:335}, eax, 0

#() [220->235] (level:0) is red with stack state with
#({basic-block #() 235 245})
  push	0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [235->245] (level:0) is red with stack state with
#({basic-block #({tag 6:335}) 335 350})
  add	esp, esp, 8
  halt	

#({tag 6:335}) [335->350] (level:1) is green with stack state with
#({basic-block #({tag 7:260}) 260 305}, {basic-block #({tag 6:335}) 335 350})
  move	N5/eax, {indirect-constant "Pruntime_thread_count"}
  add	N6/edi, N5/eax, 1
  conditional-move	{tag 6:335}, {indirect-constant "Pruntime_thread_count"}, N6/edi, N5/eax

#({tag 7:260}) [260->305] (level:0) is red with stack state with
#({basic-block #() 305 320})
  init-fpu	
  push	0
  move	N7/edi, esp
  st	-1, N0/NSPILL-0, 20
  push	0
  push	0
  push	{constant "make_foreign_thread_internal"}
  push	N7/edi
  call-alien	{constant "dylan_init_thread"}, 0

#() [305->320] (level:0) is red with stack state with
#({basic-block #({tag 1:320}) 320 330})
  add	esp, esp, 16
  add	esp, esp, 4
  st	0, N0/NSPILL-0, 20

#({tag 1:320}) [320->330] (level:0) is red with stack state with
#({basic-block #({tag 10:355}) 355 360})
  set-teb	N0/NSPILL-0
  move	eax, N0/NSPILL-0

#({tag 10:355}) [355->360] (level:0) is #f with stack state #f
#({basic-block #() 330 335})
  preserve-registers-exit	

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

+++ ending code for primitive_ensure_valid_teb +++

+++ Frame sizes for primitive_ensure_valid_teb: GC: 0, NC: 2 +++

+++ Live variable scopes for primitive_ensure_valid_teb +++
Start scope at 3 with frame for no variables
End scope at 376

+++ No Source Code Locators for primitive_ensure_valid_teb +++


+++ Exported function definition dylan_call_in +++

+++ starting code for dylan_call_in +++

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

#({tag 3:105}) [105->120] (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 65})
  move	N4/NSPILL-0, ecx
  move	N5/NSPILL-1, eax
  call	{constant "primitive_ensure_valid_teb"}, 0

#() [20->65] (level:0) is red with stack state with
#({basic-block #() 65 95})
  move	N0/edi, eax
  st	-1, N0/edi, 20
  load-address-of-stack-arg-n	#t, N2/edx, 0
  push	N2/edx
  push	N5/NSPILL-1
  move	N3/edx, esp
  push	N4/NSPILL-0
  push	N3/edx
  call-alien	{constant "dylan_callin_handler"}, 0

#() [65->95] (level:0) is red with stack state with
#({basic-block #({tag 2:100}) 100 105})
  add	esp, esp, 8
  add	esp, esp, 8
  move	N1/eax, eax
  st	0, N0/edi, 20
  move	eax, N1/eax
  asl	ecx, N4/NSPILL-0, 2

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

#() [95->100] (level:0) is red with stack state #f
#()
  rts-and-drop	ecx

+++ ending code for dylan_call_in +++

+++ Frame sizes for dylan_call_in: GC: 0, NC: 2 +++

+++ Live variable scopes for dylan_call_in +++
Start scope at 7 with frame for no variables
End scope at 67

+++ No Source Code Locators for dylan_call_in +++


+++ Exported function definition dylan_call_in_syscall +++

+++ starting code for dylan_call_in_syscall +++

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

#({tag 3:100}) [100->115] (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 65})
  move	N4/NSPILL-1, ecx
  move	N5/NSPILL-0, eax
  call	{constant "primitive_ensure_valid_teb"}, 0

#() [20->65] (level:0) is red with stack state with
#({basic-block #() 65 90})
  move	N0/edi, eax
  st	-1, N0/edi, 20
  load-address-of-stack-arg-n	#t, N2/edx, 0
  push	N2/edx
  push	N5/NSPILL-0
  move	N3/edx, esp
  push	N4/NSPILL-1
  push	N3/edx
  call-alien	{constant "dylan_callin_handler"}, 0

#() [65->90] (level:0) is red with stack state with
#({basic-block #({tag 2:95}) 95 100})
  add	esp, esp, 8
  add	esp, esp, 8
  move	N1/eax, eax
  st	0, N0/edi, 20
  move	eax, N1/eax

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

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

+++ ending code for dylan_call_in_syscall +++

+++ Frame sizes for dylan_call_in_syscall: GC: 0, NC: 2 +++

+++ Live variable scopes for dylan_call_in_syscall +++
Start scope at 7 with frame for no variables
End scope at 61

+++ No Source Code Locators for dylan_call_in_syscall +++


+++ Exported function definition dylan_callin_internal +++

+++ starting code for dylan_callin_internal +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #({tag 1:25}) 25 45})
  load-stack-arg-n	#t, N0/edx, 0
  load-stack-arg-n	#t, N1/ecx, 1
  ld	N2/eax, N0/edx, 0
  ld	N3/edx, N0/edx, 4

#({tag 1:25}) [25->45] (level:0) is red with stack state with
#({basic-block #({tag 2:45}) 45 50})
  asl	N4/edi, N1/ecx, 2
  sub	esp, esp, N4/edi
  move	N5/edi, esp
  copy-words-down-w	N5/edi, N3/edx, N1/ecx

#({tag 2:45}) [45->50] (level:0) is red with stack state with
#({basic-block #() 50 50})
  call-alien	N2/eax, 0

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

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

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

+++ ending code for dylan_callin_internal +++

+++ Live variable scopes for dylan_callin_internal +++
Start scope at 7 with frame for no variables
End scope at 34

+++ No Source Code Locators for dylan_callin_internal +++


+++ Exported function definition inside_dylan_ffi_barrier +++

+++ starting code for inside_dylan_ffi_barrier +++

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

#({tag 3:55}) [55->70] (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 35})
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_get_value"}, 0

#() [15->35] (level:0) is red with stack state with
#({basic-block #() 35 40}, {basic-block #({tag 1:50}) 40 45})
  add	esp, esp, 4
  move	N0/eax, eax
  ld	N1/eax, N0/eax, 20
  beq	{tag 1:50}, N1/eax, -1

#() [35->40] (level:0) is red with stack state with
#({basic-block #({tag 1:50}) 40 45})
  move	N1/eax, 0

#({tag 1:50}) [40->45] (level:0) is red with stack state with
#({basic-block #({tag 1:50}, {tag 2:50}) 50 55})
  move	eax, N1/eax

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

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

+++ ending code for inside_dylan_ffi_barrier +++

+++ Live variable scopes for inside_dylan_ffi_barrier +++
Start scope at 3 with frame for no variables
End scope at 27

+++ No Source Code Locators for inside_dylan_ffi_barrier +++


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

+++ Exported function definition primitive_register_traced_roots +++

+++ starting code for primitive_register_traced_roots +++

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

#() [5->55] (level:0) is green with stack state before
#({basic-block #({tag 13:190}) 190 205}, {basic-block #({tag 1:80}) 80 85})
  move	N0/edx, eax
  load-stack-arg-n	#f, N1/ebx, 0
  load-stack-arg-n	#f, N2/ecx, 1
  load-stack-arg-n	#f, N3/NSPILL--3, 2
  load-stack-arg-n	#f, N4/NSPILL--4, 3
  load-stack-arg-n	#f, N5/NSPILL--5, 4
  load-stack-arg-n	#f, N6/NSPILL--6, 5
  load-stack-arg-n	#f, N7/edi, 6
  load-stack-arg-n	#f, N8/NSPILL--8, 7
  beq	{tag 1:80}, N0/edx, N1/ebx

#({tag 13:190}) [190->205] (level:0) is #f with stack state #f
#({basic-block #() 55 75})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [55->75] (level:0) is red with stack state with
#({basic-block #() 75 80})
  push	N1/ebx
  push	N0/edx
  push	N2/ecx
  call-alien	{constant "MMRegisterRootAmbig"}, 0

#() [75->80] (level:0) is red with stack state with
#({basic-block #({tag 8:150}) 150 155})
  add	esp, esp, 12

#({tag 8:150}) [150->155] (level:0) is green with stack state with
#({basic-block #({tag 9:85}) 85 105}, {basic-block #({tag 6:145}) 145 150})
  beq	{tag 6:145}, N3/NSPILL--3, N4/NSPILL--4

#({tag 9:85}) [85->105] (level:0) is red with stack state with
#({basic-block #() 105 110})
  push	N4/NSPILL--4
  push	N3/NSPILL--3
  push	N5/NSPILL--5
  call-alien	{constant "MMRegisterRootStatic"}, 0

#() [105->110] (level:0) is red with stack state with
#({basic-block #({tag 6:145}) 145 150})
  add	esp, esp, 12

#({tag 6:145}) [145->150] (level:0) is green with stack state with
#({basic-block #({tag 7:115}) 115 135}, {basic-block #({tag 4:155}) 145 145})
  beq	{tag 4:155}, N6/NSPILL--6, N7/edi

#({tag 7:115}) [115->135] (level:0) is red with stack state with
#({basic-block #() 135 140})
  push	N7/edi
  push	N6/NSPILL--6
  push	N8/NSPILL--8
  call-alien	{constant "MMRegisterRootExact"}, 0

#() [135->140] (level:0) is red with stack state with
#({basic-block #({tag 4:155}) 145 145})
  add	esp, esp, 12

#({tag 4:155}) [145->145] (level:0) is green with stack state with
#({basic-block #({tag 4:155}, {tag 10:155}) 155 160})

#({tag 4:155}, {tag 10:155}) [155->160] (level:0) is #f with stack state #f
#({basic-block #({tag 3:140}, {tag 5:140}) 140 145})
  preserve-registers-exit	

#({tag 3:140}, {tag 5:140}) [140->145] (level:0) is green with stack state #f
#()
  rts-and-drop	32

#({tag 1:80}) [80->85] (level:0) is green with stack state before
#({basic-block #({tag 12:175}) 175 190}, {basic-block #({tag 2:110}) 110 115})
  beq	{tag 2:110}, N3/NSPILL--3, N4/NSPILL--4

#({tag 12:175}) [175->190] (level:0) is #f with stack state #f
#({basic-block #({tag 9:85}) 85 105})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [205->210] (level:0) is #f with stack state #f
#()
  bra	{tag 9:85}

#({tag 2:110}) [110->115] (level:0) is green with stack state before
#({basic-block #({tag 11:160}) 160 175}, {basic-block #({tag 3:140}) 140 140})
  beq	{tag 3:140}, N6/NSPILL--6, N7/edi

#({tag 11:160}) [160->175] (level:0) is #f with stack state #f
#({basic-block #({tag 7:115}) 115 135})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [210->215] (level:0) is #f with stack state #f
#()
  bra	{tag 7:115}

#({tag 3:140}) [140->140] (level:0) is green with stack state before
#({basic-block #({tag 3:140}, {tag 5:140}) 140 145})

+++ ending code for primitive_register_traced_roots +++

+++ Live variable scopes for primitive_register_traced_roots +++
Start scope at 21 with frame for no variables
End scope at 79
Start scope at 80 no frame for no variables
End scope at 96
Start scope at 97 with frame for no variables
End scope at 107

+++ No Source Code Locators for primitive_register_traced_roots +++


+++ Exported function definition call_dylan_exit_functions_internal +++

+++ starting code for call_dylan_exit_functions_internal +++

#() [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	{constant "Kcall_application_exit_functionsVKeI"}, 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_dylan_exit_functions_internal +++

+++ Live variable scopes for call_dylan_exit_functions_internal +++
Start scope at 7 with frame for no variables
End scope at 11

+++ No Source Code Locators for call_dylan_exit_functions_internal +++


+++ Exported function definition call_dylan_exit_functions +++

+++ starting code for call_dylan_exit_functions +++

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

#() [5->15] (level:0) is green with stack state #f
#({basic-block #() 15 20})
  move	ecx, 0
  move	eax, {constant "call_dylan_exit_functions_internal"}

#() [15->20] (level:0) is green with stack state #f
#()
  jmp-alien	{constant "dylan_call_in_syscall"}, #[1, #"arg-count"], 0, #f, #f

+++ ending code for call_dylan_exit_functions +++

+++ No Source Code Locators for call_dylan_exit_functions +++


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

+++ Exported function definition primitive_deregister_traced_roots +++

+++ starting code for primitive_deregister_traced_roots +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 30}, {basic-block #({tag 1:40}) 40 55})
  move	N1/edi, eax
  load-stack-arg-n	#t, N2/NSPILL--1, 0
  load-stack-arg-n	#t, N3/NSPILL--2, 1
  bne	{tag 1:40}, {indirect-constant "Pstarted_unloading"}, 0

#() [25->30] (level:0) is red with stack state with
#({basic-block #() 30 40})
  call-alien	{constant "call_dylan_exit_functions"}, 0

#() [30->40] (level:0) is red with stack state with
#({basic-block #({tag 1:40}) 40 55})
  move	{indirect-constant "Pstarted_unloading"}, 1
  call-alien	{constant "primitive_mps_park"}, 0

#({tag 1:40}) [40->55] (level:0) is red with stack state with
#({basic-block #() 55 75})
  ld	N0/edi, N1/edi, 0
  push	N0/edi
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [55->75] (level:0) is red with stack state with
#({basic-block #() 75 95})
  add	esp, esp, 4
  ld	N0/edi, N2/NSPILL--1, 0
  push	N0/edi
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [75->95] (level:0) is red with stack state with
#({basic-block #() 95 100})
  add	esp, esp, 4
  ld	N0/edi, N3/NSPILL--2, 0
  push	N0/edi
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [95->100] (level:0) is red with stack state with
#({basic-block #({tag 2:105}) 105 110})
  add	esp, esp, 4

#({tag 2:105}) [105->110] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  preserve-registers-exit	

#() [100->105] (level:0) is red with stack state #f
#()
  rts-and-drop	8

+++ ending code for primitive_deregister_traced_roots +++

+++ Live variable scopes for primitive_deregister_traced_roots +++
Start scope at 3 with frame for no variables
End scope at 77

+++ No Source Code Locators for primitive_deregister_traced_roots +++


+++ Exported function definition dylan_init_thread_local +++

+++ starting code for dylan_init_thread_local +++

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

#() [5->5] (level:0) is green with stack state #f
#({basic-block #() 5 10})

#() [5->10] (level:0) is green with stack state #f
#()
  jmp	{constant "dylan_init_thread"}, 0, 0, #f, #f

+++ ending code for dylan_init_thread_local +++

+++ No Source Code Locators for dylan_init_thread_local +++


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

+++ Exported function definition primitive_call_first_dylan_iep +++

+++ starting code for primitive_call_first_dylan_iep +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15})
  move	N0/eax, eax

#() [10->15] (level:0) is green with stack state #f
#()
  jmp	N0/eax, 0, 0, #f, #f

+++ ending code for primitive_call_first_dylan_iep +++

+++ No Source Code Locators for primitive_call_first_dylan_iep +++


+++ 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: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 55})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->55] (level:0) is red with stack state with
#({basic-block #() 55 55})
  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

#() [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 init_dylan_data +++

+++ Live variable scopes for init_dylan_data +++
Start scope at 7 with frame for no variables
End scope at 56

+++ 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:80}) 80 95})
  rem	"This is a dummy first basic block."

#({tag 2:80}) [80->95] (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 55})
  push	0
  move	N0/NSPILL-0, esp
  call-alien	{constant "init_dylan_data"}, 0

#() [20->55] (level:0) is red with stack state with
#({basic-block #() 55 70})
  get-teb	N1/edi
  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

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

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

#() [70->75] (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 5 with frame for no variables
End scope at 62

+++ 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: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 10})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

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

#() [10->20] (level:0) is red with stack state with
#({basic-block #() 20 20})
  move	eax, eax
  call	{constant "primitive_exit_application"}, 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	

+++ ending code for dylan_main +++

+++ Live variable scopes for dylan_main +++
Start scope at 7 with frame for no variables
End scope at 17

+++ No Source Code Locators for dylan_main +++


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

+++ Exported function definition dylan_main_0 +++

+++ starting code for dylan_main_0 +++

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

#({tag 26:525}) [525->540] (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 60})
  call-alien	{constant "tlv_create_key"}, 0

#() [10->60] (level:0) is red with stack state with
#({basic-block #() 60 75})
  move	{indirect-constant "Pteb_tlv_index"}, eax
  st	0, {constant "Pmaster_gc_teb"}, 0
  st	0, {constant "Pmaster_gc_teb"}, 4
  st	0, {constant "Pmaster_teb"}, 0
  st	{constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16
  st	{constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4
  set-teb	{constant "Pmaster_teb"}
  push	{constant "Pmaster_teb"}
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [60->75] (level:0) is red with stack state with
#({basic-block #() 75 80})
  add	esp, esp, 8
  st	0, {constant "Pmaster_teb"}, 20
  call-alien	{constant "dylan_init_memory_manager"}, 0

#() [75->80] (level:0) is red with stack state with
#({basic-block #() 80 105})
  call-alien	{constant "getpagesize"}, 0

#() [80->105] (level:0) is red with stack state with
#({basic-block #() 105 115})
  sub	N0/eax, eax, 1
  or	N0/eax, N0/eax, esp
  add	N0/eax, N0/eax, 1
  push	N0/eax
  call-alien	{constant "dylan_mm_register_thread"}, 0

#() [105->115] (level:0) is red with stack state with
#({basic-block #() 115 130}, {basic-block #({tag 19:445}) 445 460})
  add	esp, esp, 4
  beq	{tag 19:445}, eax, 0

#() [115->130] (level:0) is red with stack state with
#({basic-block #() 130 140})
  push	0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [130->140] (level:0) is red with stack state with
#({basic-block #({tag 19:445}) 445 460})
  add	esp, esp, 8
  halt	

#({tag 19:445}) [445->460] (level:1) is green with stack state with
#({basic-block #({tag 20:155}) 155 165}, {basic-block #({tag 19:445}) 445 460})
  move	N1/eax, {indirect-constant "Pruntime_thread_count"}
  add	N2/edx, N1/eax, 1
  conditional-move	{tag 19:445}, {indirect-constant "Pruntime_thread_count"}, N2/edx, N1/eax

#({tag 20:155}) [155->165] (level:0) is red with stack state with
#({basic-block #() 165 175})
  init-fpu	
  call-alien	{constant "dylan_initialize"}, 0

#() [165->175] (level:0) is red with stack state with
#({basic-block #() 175 185}, {basic-block #({tag 5:210}) 210 215})
  ld	N3/edx, {constant "Pmaster_gc_teb"}, 4
  beq	{tag 5:210}, N3/edx, 0

#() [175->185] (level:0) is red with stack state with
#({basic-block #() 185 195})
  push	{constant "Pmaster_gc_teb"}
  call-alien	{constant "dylan_mm_deregister_thread_from_teb"}, 0

#() [185->195] (level:0) is red with stack state with
#({basic-block #({tag 18:430}) 430 445})
  add	esp, esp, 4
  st	0, {constant "Pmaster_gc_teb"}, 4

#({tag 18:430}) [430->445] (level:1) is green with stack state with
#({basic-block #({tag 5:210}) 210 215}, {basic-block #({tag 18:430}) 430 445})
  move	N4/eax, {indirect-constant "Pruntime_thread_count"}
  sub	N5/edx, N4/eax, 1
  conditional-move	{tag 18:430}, {indirect-constant "Pruntime_thread_count"}, N5/edx, N4/eax

#({tag 5:210}) [210->215] (level:0) is green with stack state with
#({basic-block #({tag 8:215}) 215 220})
  move	N6/NSPILL-0, {indirect-constant "Pteb_chain"}

#({tag 8:215}) [215->220] (level:1) is green with stack state with
#({basic-block #() 220 235}, {basic-block #({tag 7:370}) 370 380})
  beq	{tag 7:370}, N6/NSPILL-0, 0

#() [220->235] (level:1) is green with stack state with
#({basic-block #() 235 245}, {basic-block #({tag 9:270}) 270 280})
  add	N7/edi, N6/NSPILL-0, 12
  ld	N8/edx, N7/edi, 4
  beq	{tag 9:270}, N8/edx, 0

#() [235->245] (level:1) is red with stack state with
#({basic-block #() 245 255})
  push	N7/edi
  call-alien	{constant "dylan_mm_deregister_thread_from_teb"}, 0

#() [245->255] (level:1) is red with stack state with
#({basic-block #({tag 17:415}) 415 430})
  add	esp, esp, 4
  st	0, N7/edi, 4

#({tag 17:415}) [415->430] (level:2) is green with stack state with
#({basic-block #({tag 9:270}) 270 280}, {basic-block #({tag 17:415}) 415 430})
  move	N9/eax, {indirect-constant "Pruntime_thread_count"}
  sub	N10/edx, N9/eax, 1
  conditional-move	{tag 17:415}, {indirect-constant "Pruntime_thread_count"}, N10/edx, N9/eax

#({tag 9:270}) [270->280] (level:1) is green with stack state with
#({basic-block #({tag 15:410}) 410 415})
  ld	N6/NSPILL-0, N6/NSPILL-0, 4
  sub	N11/edx, N7/edi, 12

#({tag 15:410}) [410->415] (level:2) is green with stack state with
#({basic-block #({tag 16:285}) 285 300}, {basic-block #({tag 15:410}) 410 415})
  conditional-move	{tag 15:410}, {indirect-constant "Pruntime_spin_lock"}, 1, 0

#({tag 16:285}) [285->300] (level:1) is red with stack state with
#({basic-block #() 300 305}, {basic-block #({tag 11:305}) 305 310})
  ld	N12/eax, N11/edx, 4
  ld	N13/ebx, N11/edx, 8
  bne	{tag 11:305}, {indirect-constant "Pteb_chain"}, N11/edx

#() [300->305] (level:1) is red with stack state with
#({basic-block #({tag 12:310}) 310 315})
  move	{indirect-constant "Pteb_chain"}, N12/eax

#({tag 12:310}) [310->315] (level:1) is red with stack state with
#({basic-block #() 315 320}, {basic-block #({tag 13:320}) 320 340})
  beq	{tag 13:320}, N12/eax, 0

#() [315->320] (level:1) is red with stack state with
#({basic-block #({tag 13:320}) 320 340})
  st	N13/ebx, N12/eax, 8

#({tag 13:320}) [320->340] (level:1) is red with stack state with
#({basic-block #() 340 365})
  move	{indirect-constant "Pruntime_spin_lock"}, 0
  ld	N11/edx, N7/edi, -12
  push	N11/edx
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [340->365] (level:1) is red with stack state with
#({basic-block #() 365 370})
  add	esp, esp, 4
  sub	N11/edx, N7/edi, 12
  push	336
  push	N11/edx
  call-alien	{constant "MMFreeMisc"}, 0

#() [365->370] (level:1) is red with stack state with
#({basic-block #({tag 8:215}) 215 220})
  add	esp, esp, 8

#() [540->545] (level:0) is #f with stack state #f
#()
  bra	{tag 8:215}

#({tag 7:370}) [370->380] (level:1) is red with stack state with
#({basic-block #() 380 390})
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_destroy_key"}, 0

#() [380->390] (level:1) is red with stack state with
#({basic-block #() 390 395}, {basic-block #({tag 4:395}) 395 405})
  add	esp, esp, 4
  bne	{tag 4:395}, {indirect-constant "Pruntime_thread_count"}, 0

#() [390->395] (level:1) is red with stack state with
#({basic-block #({tag 4:395}) 395 405})
  call-alien	{constant "dylan_shut_down_memory_manager"}, 0

#({tag 4:395}) [395->405] (level:1) is red with stack state with
#({basic-block #() 405 405})
  move	eax, eax
  call	{constant "primitive_exit_application"}, 1

#() [405->405] (level:1) is red with stack state with
#({basic-block #({tag 23:490}) 490 495})

#({tag 23:490}) [490->495] (level:0) is #f with stack state #f
#({basic-block #() 405 410})
  preserve-registers-exit	

#() [405->410] (level:1) is red with stack state #f
#()
  rts	

#({tag 11:305}) [305->310] (level:1) is red with stack state with
#({basic-block #({tag 12:310}) 310 315})
  st	N12/eax, N13/ebx, 4

#() [545->550] (level:0) is #f with stack state #f
#()
  bra	{tag 12:310}

+++ ending code for dylan_main_0 +++

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

+++ Live variable scopes for dylan_main_0 +++
Start scope at 7 with frame for no variables
End scope at 472

+++ No Source Code Locators for dylan_main_0 +++


+++ 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 +++


+++ Exported function definition primitive_manual_allocate +++

+++ starting code for primitive_manual_allocate +++

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

#({tag 2:50}) [50->65] (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})
  move	eax, eax
  call	{constant "primitive_unwrap_abstract_integer"}, 1

#() [15->25] (level:0) is red with stack state with
#({basic-block #() 25 40})
  push	eax
  call-alien	{constant "mps__malloc"}, 0

#() [25->40] (level:0) is red with stack state with
#({basic-block #() 40 40})
  add	esp, esp, 4
  move	eax, eax
  call	{constant "primitive_wrap_machine_word"}, 1

#() [40->40] (level:0) is red with stack state with
#({basic-block #({tag 1:45}) 45 50})

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

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

+++ ending code for primitive_manual_allocate +++

+++ Live variable scopes for primitive_manual_allocate +++
Start scope at 3 with frame for no variables
End scope at 22

+++ No Source Code Locators for primitive_manual_allocate +++


+++ Exported function definition primitive_manual_free +++

+++ starting code for primitive_manual_free +++

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

#({tag 2:40}) [40->55] (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 30})
  ld	N0/eax, eax, 4
  push	N0/eax
  call-alien	{constant "mps__free"}, 0

#() [20->30] (level:0) is red with stack state with
#({basic-block #({tag 1:35}) 35 40})
  add	esp, esp, 4
  move	eax, {constant "KPfalseVKi"}

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

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

+++ ending code for primitive_manual_free +++

+++ Live variable scopes for primitive_manual_free +++
Start scope at 3 with frame for no variables
End scope at 20

+++ No Source Code Locators for primitive_manual_free +++


+++ Exported function definition call_first_dylan_function +++

+++ starting code for call_first_dylan_function +++

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

#({tag 8:105}) [105->120] (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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95})
  load-stack-arg-n	#t, G0/GSPILL--1, 0
  load-stack-arg-n	#t, N1/edx, 1
  beq	{tag 4:80}, N1/edx, 0

#({tag 2:20}) [20->30] (level:0) is red with stack state with
#({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50})
  load-address-of-stack-arg-n	#t, N4/ecx, 2
  bgt	{tag 6:35}, N1/edx, 0

#() [30->35] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  rem	"eliminated"

#({tag 4:80}) [80->95] (level:0) is red with stack state with
#({basic-block #() 95 95})
  move	ebx, G0/GSPILL--1
  move	ecx, N1/edx
  call-indirect	ebx, 4, 1

#() [95->95] (level:0) is red with stack state with
#({basic-block #({tag 7:100}) 100 105})

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

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

#({tag 6:35}) [35->50] (level:0) is red with stack state with
#({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95})
  ld	eax, N4/ecx, 0
  add	N5/ebx, N4/ecx, 4
  beq	{tag 4:80}, N1/edx, 1

#({tag 3:50}) [50->80] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  sub	N2/ecx, N1/edx, 1
  asl	N3/edi, N2/ecx, 2
  sub	esp, esp, N3/edi
  move	edi, esp
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N2/ecx

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

+++ ending code for call_first_dylan_function +++

+++ Live variable scopes for call_first_dylan_function +++
Start scope at 7 with frame for no variables
End scope at 30

+++ No Source Code Locators for call_first_dylan_function +++


+++ Exported function definition call_dylan_function +++

+++ starting code for call_dylan_function +++

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

#({tag 8:110}) [110->125] (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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95})
  load-stack-arg-n	#t, G0/GSPILL--1, 0
  load-stack-arg-n	#t, N1/edx, 1
  beq	{tag 4:80}, N1/edx, 0

#({tag 2:20}) [20->30] (level:0) is red with stack state with
#({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50})
  load-address-of-stack-arg-n	#t, N4/ecx, 2
  bgt	{tag 6:35}, N1/edx, 0

#() [30->35] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  rem	"eliminated"

#({tag 4:80}) [80->95] (level:0) is red with stack state with
#({basic-block #() 95 100})
  move	ebx, G0/GSPILL--1
  move	ecx, N1/edx
  call-indirect	ebx, 4, 1

#() [95->100] (level:0) is red with stack state with
#({basic-block #({tag 7:105}) 105 110})
  move	eax, eax

#({tag 7:105}) [105->110] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  preserve-registers-exit	

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

#({tag 6:35}) [35->50] (level:0) is red with stack state with
#({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95})
  ld	eax, N4/ecx, 0
  add	N5/ebx, N4/ecx, 4
  beq	{tag 4:80}, N1/edx, 1

#({tag 3:50}) [50->80] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  sub	N2/ecx, N1/edx, 1
  asl	N3/edi, N2/ecx, 2
  sub	esp, esp, N3/edi
  move	edi, esp
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N2/ecx

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

+++ ending code for call_dylan_function +++

+++ Live variable scopes for call_dylan_function +++
Start scope at 7 with frame for no variables
End scope at 30

+++ No Source Code Locators for call_dylan_function +++


+++ Exported function definition spy_call_dylan_function +++

+++ starting code for spy_call_dylan_function +++

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

#({tag 8:120}) [120->135] (level:0) is #f with stack state #f
#({basic-block #() 5 25})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->25] (level:0) is red with stack state with
#({basic-block #({tag 2:25}) 25 35}, {basic-block #({tag 4:85}) 85 100})
  load-stack-arg-n	#t, G0/GSPILL--1, 0
  load-stack-arg-n	#t, N1/edx, 1
  move	{indirect-constant "Prunning_dylan_spy_functionQ"}, 1
  beq	{tag 4:85}, N1/edx, 0

#({tag 2:25}) [25->35] (level:0) is red with stack state with
#({basic-block #() 35 40}, {basic-block #({tag 6:40}) 40 55})
  load-address-of-stack-arg-n	#t, N4/ecx, 2
  bgt	{tag 6:40}, N1/edx, 0

#() [35->40] (level:0) is red with stack state with
#({basic-block #({tag 4:85}) 85 100})
  rem	"eliminated"

#({tag 4:85}) [85->100] (level:0) is red with stack state with
#({basic-block #() 100 110})
  move	ebx, G0/GSPILL--1
  move	ecx, N1/edx
  call-indirect	ebx, 4, 1

#() [100->110] (level:0) is red with stack state with
#({basic-block #({tag 7:115}) 115 120})
  move	eax, eax
  move	{indirect-constant "Prunning_dylan_spy_functionQ"}, 0

#({tag 7:115}) [115->120] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  preserve-registers-exit	

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

#({tag 6:40}) [40->55] (level:0) is red with stack state with
#({basic-block #({tag 3:55}) 55 85}, {basic-block #({tag 4:85}) 85 100})
  ld	eax, N4/ecx, 0
  add	N5/ebx, N4/ecx, 4
  beq	{tag 4:85}, N1/edx, 1

#({tag 3:55}) [55->85] (level:0) is red with stack state with
#({basic-block #({tag 4:85}) 85 100})
  sub	N2/ecx, N1/edx, 1
  asl	N3/edi, N2/ecx, 2
  sub	esp, esp, N3/edi
  move	edi, esp
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N2/ecx

#() [135->140] (level:0) is #f with stack state #f
#()
  bra	{tag 4:85}

+++ ending code for spy_call_dylan_function +++

+++ Live variable scopes for spy_call_dylan_function +++
Start scope at 7 with frame for no variables
End scope at 50

+++ No Source Code Locators for spy_call_dylan_function +++


+++ Exported function definition call_dylan_function_returning_all_values +++

+++ starting code for call_dylan_function_returning_all_values +++

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

#({tag 14:245}) [245->260] (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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95})
  load-stack-arg-n	#t, G0/GSPILL--1, 0
  load-stack-arg-n	#t, N1/edx, 1
  beq	{tag 4:80}, N1/edx, 0

#({tag 2:20}) [20->30] (level:0) is red with stack state with
#({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50})
  load-address-of-stack-arg-n	#t, N4/ecx, 2
  bgt	{tag 6:35}, N1/edx, 0

#() [30->35] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  rem	"eliminated"

#({tag 4:80}) [80->95] (level:0) is red with stack state with
#({basic-block #() 95 110})
  move	ebx, G0/GSPILL--1
  move	ecx, N1/edx
  call-indirect	ebx, 4, 1

#() [95->110] (level:0) is red with stack state with
#({basic-block #() 110 115}, {basic-block #({tag 7:130}) 130 140})
  move	N8/edx, 0
  ld-teb-address	N7/edi, 36
  bmvset	{tag 7:130}

#() [110->115] (level:0) is red with stack state with
#({basic-block #() 115 125}, {basic-block #({tag 9:125}) 125 130})
  bne	{tag 9:125}, N8/edx, 0

#() [115->125] (level:0) is red with stack state with
#({basic-block #({tag 8:170}) 170 175})
  st	eax, N7/edi, 0
  move	N6/edx, 1

#({tag 8:170}) [170->175] (level:0) is red with stack state with
#({basic-block #() 175 180}, {basic-block #({tag 12:180}) 180 220})
  bne	{tag 12:180}, N6/edx, 0

#() [175->180] (level:0) is red with stack state with
#({basic-block #({tag 11:240}) 230 235})
  move	G10/eax, {constant "KPempty_vectorVKi"}

#({tag 11:240}) [230->235] (level:0) is red with stack state with
#({basic-block #({tag 11:240}, {tag 13:240}) 240 245})
  move	eax, G10/eax

#({tag 11:240}, {tag 13:240}) [240->245] (level:0) is #f with stack state #f
#({basic-block #() 235 240})
  preserve-registers-exit	

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

#({tag 6:35}) [35->50] (level:0) is red with stack state with
#({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95})
  ld	eax, N4/ecx, 0
  add	N5/ebx, N4/ecx, 4
  beq	{tag 4:80}, N1/edx, 1

#({tag 3:50}) [50->80] (level:0) is red with stack state with
#({basic-block #({tag 4:80}) 80 95})
  sub	N2/ecx, N1/edx, 1
  asl	N3/edi, N2/ecx, 2
  sub	esp, esp, N3/edi
  move	edi, esp
  move	esi, N5/ebx
  copy-words-down-w	edi, esi, N2/ecx

#() [260->265] (level:0) is #f with stack state #f
#()
  bra	{tag 4:80}

#({tag 7:130}) [130->140] (level:0) is red with stack state with
#({basic-block #() 140 145}, {basic-block #({tag 9:125}) 125 130})
  ld-teb	N9/ebx, 32
  bge	{tag 9:125}, N8/edx, N9/ebx

#() [140->145] (level:0) is red with stack state with
#({basic-block #() 145 150}, {basic-block #({tag 10:150}) 150 170})
  bne	{tag 10:150}, N8/edx, 0

#() [145->150] (level:0) is red with stack state with
#({basic-block #({tag 10:150}) 150 170})
  st	eax, N7/edi, 0

#({tag 10:150}) [150->170] (level:0) is red with stack state with
#({basic-block #({tag 8:170}) 170 175})
  sub	N9/ebx, N9/ebx, N8/edx
  asl	N8/edx, N8/edx, 2
  add	N7/edi, N7/edi, N8/edx
  move	N6/edx, N9/ebx

#() [265->270] (level:0) is #f with stack state #f
#()
  bra	{tag 8:170}

#({tag 9:125}) [125->130] (level:0) is red with stack state with
#({basic-block #({tag 8:170}) 170 175})
  move	N6/edx, 0

#() [270->275] (level:0) is #f with stack state #f
#()
  bra	{tag 8:170}

#({tag 12:180}) [180->220] (level:0) is red with stack state with
#({basic-block #() 220 230})
  asl	N11/ecx, N6/edx, 2
  add	N11/ecx, N11/ecx, 8
  push	N7/edi
  push	1
  push	N6/edx
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N11/ecx
  call-alien	{constant "primitive_alloc_rt"}, 0

#() [220->230] (level:0) is red with stack state with
#({basic-block #({tag 11:240}) 230 235})
  add	esp, esp, 20
  move	G10/eax, eax

#() [275->280] (level:0) is #f with stack state #f
#()
  bra	{tag 11:240}

+++ ending code for call_dylan_function_returning_all_values +++

+++ Live variable scopes for call_dylan_function_returning_all_values +++
Start scope at 7 with frame for no variables
End scope at 71

+++ No Source Code Locators for call_dylan_function_returning_all_values +++


+++ Exported function definition make_dylan_vector +++

+++ starting code for make_dylan_vector +++

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

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

#() [5->50] (level:0) is red with stack state with
#({basic-block #() 50 65})
  load-stack-arg-n	#t, N0/ecx, 0
  asl	N2/edx, N0/ecx, 2
  add	N2/edx, N2/edx, 8
  push	{constant "KPunboundVKi"}
  push	1
  push	N0/ecx
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N2/edx
  call-alien	{constant "primitive_alloc_rf"}, 0

#() [50->65] (level:0) is red with stack state with
#({basic-block #({tag 1:70}) 70 75})
  add	esp, esp, 20
  move	G1/eax, eax
  move	eax, G1/eax

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

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

+++ ending code for make_dylan_vector +++

+++ Live variable scopes for make_dylan_vector +++
Start scope at 3 with frame for no variables
End scope at 36

+++ No Source Code Locators for make_dylan_vector +++


+++ Exported function definition get_current_teb +++

+++ starting code for get_current_teb +++

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

#() [5->10] (level:0) is green with stack state #f
#({basic-block #() 10 15})
  get-teb	eax

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

+++ ending code for get_current_teb +++

+++ No Source Code Locators for get_current_teb +++


+++ Exported function definition get_tlv_vector +++

+++ starting code for get_tlv_vector +++

#() [0->5] (level:0) is green 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 green with stack state with
#({basic-block #({tag 1:15}) 15 20})
  ld-teb	eax, 4

#({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 green with stack state #f
#()
  rts	

+++ ending code for get_tlv_vector +++

+++ Live variable scopes for get_tlv_vector +++
Start scope at 4 with frame for no variables
End scope at 13

+++ No Source Code Locators for get_tlv_vector +++


+++ Exported function definition set_tlv_vector +++

+++ starting code for set_tlv_vector +++

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

#({tag 2:25}) [25->40] (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 green with stack state with
#({basic-block #({tag 1:20}) 20 25})
  load-stack-arg-n	#t, G0/edx, 0
  st-teb	G0/edx, 4

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

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

+++ ending code for set_tlv_vector +++

+++ Live variable scopes for set_tlv_vector +++
Start scope at 4 with frame for no variables
End scope at 16

+++ No Source Code Locators for set_tlv_vector +++


+++ Exported function definition get_current_thread +++

+++ starting code for get_current_thread +++

#() [0->5] (level:0) is green 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 green with stack state with
#({basic-block #({tag 1:15}) 15 20})
  ld-teb	eax, 8

#({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 green with stack state #f
#()
  rts	

+++ ending code for get_current_thread +++

+++ Live variable scopes for get_current_thread +++
Start scope at 4 with frame for no variables
End scope at 13

+++ No Source Code Locators for get_current_thread +++


+++ Exported function definition set_current_thread +++

+++ starting code for set_current_thread +++

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

#({tag 2:25}) [25->40] (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 green with stack state with
#({basic-block #({tag 1:20}) 20 25})
  load-stack-arg-n	#t, G0/edx, 0
  st-teb	G0/edx, 8

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

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

+++ ending code for set_current_thread +++

+++ Live variable scopes for set_current_thread +++
Start scope at 4 with frame for no variables
End scope at 16

+++ No Source Code Locators for set_current_thread +++


+++ Exported function definition get_current_thread_handle +++

+++ starting code for get_current_thread_handle +++

#() [0->5] (level:0) is green 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 green with stack state with
#({basic-block #({tag 1:15}) 15 20})
  ld-teb	eax, 12

#({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 green with stack state #f
#()
  rts	

+++ ending code for get_current_thread_handle +++

+++ Live variable scopes for get_current_thread_handle +++
Start scope at 4 with frame for no variables
End scope at 13

+++ No Source Code Locators for get_current_thread_handle +++


+++ Exported function definition set_current_thread_handle +++

+++ starting code for set_current_thread_handle +++

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

#({tag 2:25}) [25->40] (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 green with stack state with
#({basic-block #({tag 1:20}) 20 25})
  load-stack-arg-n	#t, G0/edx, 0
  st-teb	G0/edx, 12

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

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

+++ ending code for set_current_thread_handle +++

+++ Live variable scopes for set_current_thread_handle +++
Start scope at 4 with frame for no variables
End scope at 16

+++ No Source Code Locators for set_current_thread_handle +++


+++ Exported function definition spy_call_interactive_function +++

+++ starting code for spy_call_interactive_function +++

#() [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 30})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 70})
  load-stack-arg-n	#t, N0/edi, 0
  move	G2/edx, {constant "Kmake_simple_lockYthreads_primitivesVdylan"}
  push	G2/edx
  push	16
  call-alien	{constant "primitive_copy"}, 0

#() [30->70] (level:0) is red with stack state with
#({basic-block #() 70 75})
  add	esp, esp, 8
  move	G1/eax, eax
  st	N0/edi, G1/eax, 12
  push	G1/eax
  move	eax, -3
  move	ebx, {indirect-constant "spy_invoke_dylan_under_coded_restartVKi"}
  move	ecx, 2
  call-indirect	ebx, 4, 1

#() [70->75] (level:0) is red with stack state with
#({basic-block #({tag 1:80}) 80 85})
  move	eax, eax

#({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 spy_call_interactive_function +++

+++ Live variable scopes for spy_call_interactive_function +++
Start scope at 7 with frame for no variables
End scope at 49

+++ No Source Code Locators for spy_call_interactive_function +++


+++ Exported function definition spy_read_location_through_barrier +++

+++ starting code for spy_read_location_through_barrier +++

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

#() [5->15] (level:0) is green with stack state #f
#({basic-block #() 15 20})
  load-stack-arg-n	#f, N0/eax, 0
  ld	eax, N0/eax, 0

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

+++ ending code for spy_read_location_through_barrier +++

+++ No Source Code Locators for spy_read_location_through_barrier +++


+++ Exported function definition spy_write_location_through_barrier +++

+++ starting code for spy_write_location_through_barrier +++

#() [0->5] (level:0) is green 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 green with stack state with
#({basic-block #({tag 1:25}) 25 30})
  load-stack-arg-n	#t, N0/edi, 0
  load-stack-arg-n	#t, N1/edx, 1
  st	N1/edx, N0/edi, 0

#({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 green with stack state #f
#()
  rts	

+++ ending code for spy_write_location_through_barrier +++

+++ Live variable scopes for spy_write_location_through_barrier +++
Start scope at 5 with frame for no variables
End scope at 12

+++ No Source Code Locators for spy_write_location_through_barrier +++


+++ Exported function definition spy_read_thread_variable_at_offset +++

+++ starting code for spy_read_thread_variable_at_offset +++

#() [0->5] (level:0) is green 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 green with stack state with
#({basic-block #({tag 1:25}) 25 30})
  load-stack-arg-n	#t, N0/edx, 0
  ld-teb	G1/eax, 4
  ld-index-scaled	eax, G1/eax, N0/edx, 0

#({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 green with stack state #f
#()
  rts	

+++ ending code for spy_read_thread_variable_at_offset +++

+++ Live variable scopes for spy_read_thread_variable_at_offset +++
Start scope at 4 with frame for no variables
End scope at 19

+++ No Source Code Locators for spy_read_thread_variable_at_offset +++


+++ Exported function definition spy_start_debugger_transaction +++

+++ starting code for spy_start_debugger_transaction +++

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

#() [5->5] (level:0) is green with stack state #f
#({basic-block #() 5 10})

#() [5->10] (level:0) is green with stack state #f
#()
  jmp-alien	{constant "primitive_mps_park"}, 0, 0, #f, #f

+++ ending code for spy_start_debugger_transaction +++

+++ No Source Code Locators for spy_start_debugger_transaction +++


+++ Exported function definition spy_end_debugger_transaction +++

+++ starting code for spy_end_debugger_transaction +++

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

#() [5->5] (level:0) is green with stack state #f
#({basic-block #() 5 10})

#() [5->10] (level:0) is green with stack state #f
#()
  jmp-alien	{constant "primitive_mps_release"}, 0, 0, #f, #f

+++ ending code for spy_end_debugger_transaction +++

+++ No Source Code Locators for spy_end_debugger_transaction +++


+++ Exported function definition spy_fixup_imported_dylan_data +++

+++ starting code for spy_fixup_imported_dylan_data +++

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

#() [5->5] (level:0) is green with stack state #f
#({basic-block #() 5 10})

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

+++ ending code for spy_fixup_imported_dylan_data +++

+++ No Source Code Locators for spy_fixup_imported_dylan_data +++


+++ Exported function definition spy_fixup_unimported_dylan_data +++

+++ starting code for spy_fixup_unimported_dylan_data +++

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

#() [5->5] (level:0) is green with stack state #f
#({basic-block #() 5 10})

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

+++ ending code for spy_fixup_unimported_dylan_data +++

+++ No Source Code Locators for spy_fixup_unimported_dylan_data +++


+++ Exported function definition spy_exit_application +++

+++ starting code for spy_exit_application +++

#() [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 15})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

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

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

#({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	

+++ ending code for spy_exit_application +++

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

+++ No Source Code Locators for spy_exit_application +++


+++ Exported function definition c_primitive_raw_as_string +++

+++ starting code for c_primitive_raw_as_string +++

#() [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})
  load-stack-arg-n	#t, N0/eax, 0
  move	eax, N0/eax
  call	{constant "primitive_raw_as_string"}, 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	

+++ ending code for c_primitive_raw_as_string +++

+++ Live variable scopes for c_primitive_raw_as_string +++
Start scope at 7 with frame for no variables
End scope at 14

+++ No Source Code Locators for c_primitive_raw_as_string +++


+++ Exported function definition primitive_check_specializers +++

+++ starting code for primitive_check_specializers +++

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

#() [5->70] (level:0) is #f with stack state #f
#({basic-block #() 70 90}, {basic-block #({tag 4:125}) 125 130})
  preserve-registers-entry	
  move	N2/ecx, ecx
  ld	G1/edx, ebx, 8
  ld	G1/edx, G1/edx, 8
  push	G1/edx
  push	0
  push	0
  push	N2/ecx
  push	eax
  push	ebx
  push	edi
  ld	esi, G1/edx, 8
  beq	{tag 4:125}, esi, {constant "KLobjectGVKd"}

#() [70->90] (level:0) is #f with stack state #f
#({basic-block #() 90 95}, {basic-block #({tag 6:95}) 95 115})
  store-frame-offset	esi, -3
  store-frame-offset	eax, -2
  move	G4/edi, esi
  bne	{tag 6:95}, G4/edi, {constant "KLobjectGVKd"}

#() [90->95] (level:0) is #f with stack state #f
#({basic-block #({tag 5:115}) 115 125})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:115}) [115->125] (level:0) is #f with stack state #f
#({basic-block #({tag 4:125}) 125 130}, {basic-block #({tag 1:280}) 280 305})
  load-frame-offset	#t, G1/edx, -1
  beq	{tag 1:280}, eax, {constant "KPfalseVKi"}

#({tag 4:125}) [125->130] (level:0) is #f with stack state #f
#({basic-block #({tag 2:130}) 130 135})
  load-frame-offset	#t, N2/ecx, -4

#({tag 2:130}) [130->135] (level:2) is #f with stack state #f
#({basic-block #() 135 150}, {basic-block #({tag 3:225}) 225 270})
  ble	{tag 3:225}, N2/ecx, 4

#() [135->150] (level:2) is #f with stack state #f
#({basic-block #() 150 185}, {basic-block #({tag 2:130}) 130 135})
  sub	N2/ecx, N2/ecx, 4
  ld-index	esi, G1/edx, N2/ecx, 8
  beq	{tag 2:130}, esi, {constant "KLobjectGVKd"}

#() [150->185] (level:1) is #f with stack state #f
#({basic-block #() 185 190}, {basic-block #({tag 8:190}) 190 210})
  add	N5/eax, N2/ecx, 4
  ld	G0/eax, ebp, N5/eax
  store-frame-offset	esi, -3
  store-frame-offset	G0/eax, -2
  store-frame-offset	N2/ecx, -4
  move	G7/edi, esi
  bne	{tag 8:190}, G7/edi, {constant "KLobjectGVKd"}

#() [185->190] (level:1) is #f with stack state #f
#({basic-block #({tag 7:210}) 210 225})
  move	eax, {constant "KPtrueVKi"}

#({tag 7:210}) [210->225] (level:1) is #f with stack state #f
#({basic-block #({tag 2:130}) 130 135}, {basic-block #({tag 1:280}) 280 305})
  load-frame-offset	#t, N2/ecx, -4
  load-frame-offset	#t, G1/edx, -1
  bne	{tag 2:130}, eax, {constant "KPfalseVKi"}

#({tag 1:280}) [280->305] (level:0) is #f with stack state #f
#({basic-block #() 305 305})
  load-frame-offset	#t, G10/edi, -3
  load-frame-offset	#t, G9/eax, -2
  push	G10/edi
  move	eax, G9/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [305->305] (level:0) is #f with stack state #f
#({basic-block #() 305 310})

#() [305->310] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:95}) [95->115] (level:0) is #f with stack state #f
#({basic-block #({tag 5:115}) 115 125})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, eax
  call	N3/ebx, 1

#() [310->315] (level:0) is #f with stack state #f
#()
  bra	{tag 5:115}

#({tag 3:225}) [225->270] (level:2) is #f with stack state #f
#({basic-block #() 270 270}, {basic-block #({tag 9:275}) 275 275})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	
  ld	N8/edx, ebx, 8
  ld	N8/edx, N8/edx, 4
  and	N8/edx, N8/edx, 262144
  bne	{tag 9:275}, N8/edx, 0

#() [270->270] (level:2) is #f with stack state #f
#({basic-block #() 270 275})

#() [270->275] (level:2) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 8:190}) [190->210] (level:1) is #f with stack state #f
#({basic-block #({tag 7:210}) 210 225})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G0/eax
  call	N6/ebx, 1

#() [315->320] (level:0) is #f with stack state #f
#()
  bra	{tag 7:210}

#({tag 9:275}) [275->275] (level:2) is #f with stack state #f
#({basic-block #({tag 9:275}) 275 280})

#({tag 9:275}) [275->280] (level:2) is #f with stack state #f
#()
  jmp-indirect	ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for primitive_check_specializers +++

+++ Live variable scopes for primitive_check_specializers +++
Start scope at 3 with frame for no variables
End scope at 149

+++ No Source Code Locators for primitive_check_specializers +++


+++ Exported function definition primitive_process_keys +++

+++ starting code for primitive_process_keys +++

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

#() [5->85] (level:0) is #f with stack state #f
#({basic-block #({tag 4:85}) 85 90})
  ld	G0/edx, ebx, 20
  push	eax
  push	ebx
  push	edi
  push	G0/edx
  ld	G2/edi, ebx, 8
  ld	G2/edi, G2/edi, 4
  and	N4/edi, G2/edi, 524288
  push	N4/edi
  ld	G1/edx, ebx, 20
  ld	N9/edi, G1/edx, 4
  sub	N9/edi, N9/edi, 1
  lsr	N10/eax, N9/edi, 1
  add	N12/ebx, G1/edx, 12
  sub	N11/edi, ecx, N10/eax
  add	N11/edi, N11/edi, 4

#({tag 4:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 5:110}) 110 125})
  bhi	{tag 5:110}, N11/edi, ecx

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 4:85}) 85 90})
  ld	G13/eax, N12/ebx, 0
  st	G13/eax, N11/edi, 0
  add	N12/ebx, N12/ebx, 8
  add	N11/edi, N11/edi, 4

#() [315->320] (level:0) is #f with stack state #f
#()
  bra	{tag 4:85}

#({tag 5:110}) [110->125] (level:1) is #f with stack state #f
#({basic-block #() 125 165}, {basic-block #({tag 1:170}) 170 225})
  ld	N5/ebx, esi, 4
  sub	N5/ebx, N5/ebx, 1
  nbit	{tag 1:170}, N5/ebx, 4, 0

#() [125->165] (level:1) is #f with stack state #f
#({basic-block #() 165 165})
  add	esp, esp, 4
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax
  preserve-registers-entry	
  move	eax, ebx
  call	{constant "Kodd_keyword_arguments_errorVKiI"}, 1

#() [165->165] (level:1) is #f with stack state #f
#({basic-block #() 165 170})

#() [165->170] (level:1) is #f with stack state #f
#()
  rts	

#({tag 1:170}) [170->225] (level:1) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285})
  add	N3/edi, esi, 8
  add	esi, N5/ebx, N3/edi
  ld	N6/eax, G1/edx, 4
  sub	N6/eax, N6/eax, 1
  add	N7/edx, G1/edx, 8
  add	N8/ebx, N7/edx, N6/eax
  sub	N8/ebx, N8/ebx, 8
  asr	N6/eax, N6/eax, 1
  sub	ecx, ecx, N6/eax
  add	ecx, ecx, 4
  push	N3/edi

#({tag 2:270}, {tag 9:270}) [270->285] (level:3) is #f with stack state #f
#({basic-block #() 285 310}, {basic-block #({tag 3:225}) 225 235})
  sub	esi, esi, 8
  ld	N3/edi, esp, 0
  bhs	{tag 3:225}, esi, N3/edi

#() [285->310] (level:1) is #f with stack state #f
#({basic-block #() 310 315})
  add	esp, esp, 8
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax

#() [310->315] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 3:225}) [225->235] (level:3) is #f with stack state #f
#({basic-block #({tag 7:245}) 245 250})
  ld	G15/eax, esi, 0
  move	N17/edi, N7/edx

#({tag 7:245}) [245->250] (level:4) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285}, {basic-block #({tag 6:235}) 235 240})
  bhi	{tag 2:270}, N17/edi, N8/ebx

#({tag 6:235}) [235->240] (level:3) is #f with stack state #f
#({basic-block #() 240 245}, {basic-block #({tag 8:250}) 250 270})
  beq-mem	{tag 8:250}, N17/edi, 0, G15/eax

#() [240->245] (level:2) is #f with stack state #f
#({basic-block #({tag 7:245}) 245 250})
  add	N17/edi, N17/edi, 8

#() [320->325] (level:0) is #f with stack state #f
#()
  bra	{tag 7:245}

#({tag 8:250}) [250->270] (level:3) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285})
  sub	N16/edi, N17/edi, N7/edx
  asr	N16/edi, N16/edi, 1
  ld	G14/eax, esi, 4
  st	G14/eax, ecx, N16/edi

#() [325->330] (level:0) is #f with stack state #f
#()
  bra	{tag 2:270}

+++ ending code for primitive_process_keys +++

+++ No Source Code Locators for primitive_process_keys +++


+++ Exported function definition primitive_process_keys_for_xep +++

+++ starting code for primitive_process_keys_for_xep +++

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

#() [5->85] (level:0) is #f with stack state #f
#({basic-block #({tag 4:85}) 85 90})
  ld	G0/edx, ebx, 20
  push	eax
  push	ebx
  push	edi
  push	G0/edx
  ld	G2/edi, ebx, 8
  ld	G2/edi, G2/edi, 4
  and	N4/edi, G2/edi, 524288
  push	N4/edi
  ld	G1/edx, ebx, 20
  ld	N9/edi, G1/edx, 4
  sub	N9/edi, N9/edi, 1
  lsr	N10/eax, N9/edi, 1
  add	N12/ebx, G1/edx, 12
  sub	N11/edi, ecx, N10/eax
  add	N11/edi, N11/edi, 4

#({tag 4:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 5:110}) 110 125})
  bhi	{tag 5:110}, N11/edi, ecx

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 4:85}) 85 90})
  ld	G13/eax, N12/ebx, 0
  st	G13/eax, N11/edi, 0
  add	N12/ebx, N12/ebx, 8
  add	N11/edi, N11/edi, 4

#() [315->320] (level:0) is #f with stack state #f
#()
  bra	{tag 4:85}

#({tag 5:110}) [110->125] (level:1) is #f with stack state #f
#({basic-block #() 125 165}, {basic-block #({tag 1:170}) 170 225})
  ld	N5/ebx, esi, 4
  sub	N5/ebx, N5/ebx, 1
  nbit	{tag 1:170}, N5/ebx, 4, 0

#() [125->165] (level:1) is #f with stack state #f
#({basic-block #() 165 165})
  add	esp, esp, 4
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax
  preserve-registers-entry	
  move	eax, ebx
  call	{constant "Kodd_keyword_arguments_errorVKiI"}, 1

#() [165->165] (level:1) is #f with stack state #f
#({basic-block #() 165 170})

#() [165->170] (level:1) is #f with stack state #f
#()
  rts	

#({tag 1:170}) [170->225] (level:1) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285})
  add	N3/edi, esi, 8
  add	esi, N5/ebx, N3/edi
  ld	N6/eax, G1/edx, 4
  sub	N6/eax, N6/eax, 1
  add	N7/edx, G1/edx, 8
  add	N8/ebx, N7/edx, N6/eax
  sub	N8/ebx, N8/ebx, 8
  asr	N6/eax, N6/eax, 1
  sub	ecx, ecx, N6/eax
  add	ecx, ecx, 4
  push	N3/edi

#({tag 2:270}, {tag 9:270}) [270->285] (level:3) is #f with stack state #f
#({basic-block #() 285 310}, {basic-block #({tag 3:225}) 225 235})
  sub	esi, esi, 8
  ld	N3/edi, esp, 0
  bhs	{tag 3:225}, esi, N3/edi

#() [285->310] (level:1) is #f with stack state #f
#({basic-block #() 310 315})
  add	esp, esp, 8
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax

#() [310->315] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 3:225}) [225->235] (level:3) is #f with stack state #f
#({basic-block #({tag 7:245}) 245 250})
  ld	G15/eax, esi, 0
  move	N17/edi, N7/edx

#({tag 7:245}) [245->250] (level:4) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285}, {basic-block #({tag 6:235}) 235 240})
  bhi	{tag 2:270}, N17/edi, N8/ebx

#({tag 6:235}) [235->240] (level:3) is #f with stack state #f
#({basic-block #() 240 245}, {basic-block #({tag 8:250}) 250 270})
  beq-mem	{tag 8:250}, N17/edi, 0, G15/eax

#() [240->245] (level:2) is #f with stack state #f
#({basic-block #({tag 7:245}) 245 250})
  add	N17/edi, N17/edi, 8

#() [320->325] (level:0) is #f with stack state #f
#()
  bra	{tag 7:245}

#({tag 8:250}) [250->270] (level:3) is #f with stack state #f
#({basic-block #({tag 2:270}, {tag 9:270}) 270 285})
  sub	N16/edi, N17/edi, N7/edx
  asr	N16/edi, N16/edi, 1
  ld	G14/eax, esi, 4
  st	G14/eax, ecx, N16/edi

#() [325->330] (level:0) is #f with stack state #f
#()
  bra	{tag 2:270}

+++ ending code for primitive_process_keys_for_xep +++

+++ No Source Code Locators for primitive_process_keys_for_xep +++


+++ Exported function definition primitive_process_keys_checking_args_for_xep +++

+++ starting code for primitive_process_keys_checking_args_for_xep +++

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

#() [5->85] (level:0) is #f with stack state #f
#({basic-block #({tag 5:85}) 85 90})
  ld	G1/edx, ebx, 20
  push	eax
  push	ebx
  push	edi
  push	G1/edx
  ld	G3/edi, ebx, 8
  ld	G3/edi, G3/edi, 4
  and	N5/edi, G3/edi, 524288
  push	N5/edi
  ld	G2/edx, ebx, 20
  ld	N10/edi, G2/edx, 4
  sub	N10/edi, N10/edi, 1
  lsr	N11/eax, N10/edi, 1
  add	N13/ebx, G2/edx, 12
  sub	N12/edi, ecx, N11/eax
  add	N12/edi, N12/edi, 4

#({tag 5:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 6:110}) 110 125})
  bhi	{tag 6:110}, N12/edi, ecx

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 5:85}) 85 90})
  ld	G14/eax, N13/ebx, 0
  st	G14/eax, N12/edi, 0
  add	N13/ebx, N13/ebx, 8
  add	N12/edi, N12/edi, 4

#() [605->610] (level:0) is #f with stack state #f
#()
  bra	{tag 5:85}

#({tag 6:110}) [110->125] (level:1) is #f with stack state #f
#({basic-block #() 125 165}, {basic-block #({tag 2:170}) 170 225})
  ld	N6/ebx, esi, 4
  sub	N6/ebx, N6/ebx, 1
  nbit	{tag 2:170}, N6/ebx, 4, 0

#() [125->165] (level:1) is #f with stack state #f
#({basic-block #() 165 165})
  add	esp, esp, 4
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax
  preserve-registers-entry	
  move	eax, ebx
  call	{constant "Kodd_keyword_arguments_errorVKiI"}, 1

#() [165->165] (level:1) is #f with stack state #f
#({basic-block #() 165 170})

#() [165->170] (level:1) is #f with stack state #f
#()
  rts	

#({tag 2:170}) [170->225] (level:1) is #f with stack state #f
#({basic-block #({tag 3:270}, {tag 10:270}) 270 285})
  add	N4/edi, esi, 8
  add	esi, N6/ebx, N4/edi
  ld	N7/eax, G2/edx, 4
  sub	N7/eax, N7/eax, 1
  add	N8/edx, G2/edx, 8
  add	N9/ebx, N8/edx, N7/eax
  sub	N9/ebx, N9/ebx, 8
  asr	N7/eax, N7/eax, 1
  sub	ecx, ecx, N7/eax
  add	ecx, ecx, 4
  push	N4/edi

#({tag 3:270}, {tag 10:270}) [270->285] (level:3) is #f with stack state #f
#({basic-block #() 285 390}, {basic-block #({tag 4:225}) 225 235})
  sub	esi, esi, 8
  ld	N4/edi, esp, 0
  bhs	{tag 4:225}, esi, N4/edi

#() [285->390] (level:1) is #f with stack state #f
#({basic-block #() 390 410}, {basic-block #({tag 15:445}) 445 450})
  add	esp, esp, 8
  add	esp, esp, 4
  pop	edi
  pop	ebx
  pop	eax
  preserve-registers-entry	
  ld	N0/edx, ebx, 8
  ld	N0/edx, N0/edx, 4
  and	N0/edx, N0/edx, 1020
  move	N23/edx, N0/edx
  ld	G22/ecx, ebx, 8
  ld	G22/ecx, G22/ecx, 8
  push	G22/ecx
  push	0
  push	0
  push	N23/edx
  push	eax
  push	ebx
  push	edi
  ld	esi, G22/ecx, 8
  beq	{tag 15:445}, esi, {constant "KLobjectGVKd"}

#() [390->410] (level:1) is #f with stack state #f
#({basic-block #() 410 415}, {basic-block #({tag 17:415}) 415 435})
  store-frame-offset	esi, -3
  store-frame-offset	eax, -2
  move	G25/edi, esi
  bne	{tag 17:415}, G25/edi, {constant "KLobjectGVKd"}

#() [410->415] (level:1) is #f with stack state #f
#({basic-block #({tag 16:435}) 435 445})
  move	eax, {constant "KPtrueVKi"}

#({tag 16:435}) [435->445] (level:1) is #f with stack state #f
#({basic-block #({tag 15:445}) 445 450}, {basic-block #({tag 1:575}) 575 600})
  load-frame-offset	#t, G22/ecx, -1
  beq	{tag 1:575}, eax, {constant "KPfalseVKi"}

#({tag 15:445}) [445->450] (level:1) is #f with stack state #f
#({basic-block #({tag 13:450}) 450 455})
  load-frame-offset	#t, N23/edx, -4

#({tag 13:450}) [450->455] (level:3) is #f with stack state #f
#({basic-block #() 455 470}, {basic-block #({tag 14:545}) 545 570})
  ble	{tag 14:545}, N23/edx, 4

#() [455->470] (level:3) is #f with stack state #f
#({basic-block #() 470 505}, {basic-block #({tag 13:450}) 450 455})
  sub	N23/edx, N23/edx, 4
  ld-index	esi, G22/ecx, N23/edx, 8
  beq	{tag 13:450}, esi, {constant "KLobjectGVKd"}

#() [470->505] (level:2) is #f with stack state #f
#({basic-block #() 505 510}, {basic-block #({tag 19:510}) 510 530})
  add	N26/eax, N23/edx, 4
  ld	G21/eax, ebp, N26/eax
  store-frame-offset	esi, -3
  store-frame-offset	G21/eax, -2
  store-frame-offset	N23/edx, -4
  move	G28/edi, esi
  bne	{tag 19:510}, G28/edi, {constant "KLobjectGVKd"}

#() [505->510] (level:2) is #f with stack state #f
#({basic-block #({tag 18:530}) 530 545})
  move	eax, {constant "KPtrueVKi"}

#({tag 18:530}) [530->545] (level:2) is #f with stack state #f
#({basic-block #({tag 13:450}) 450 455}, {basic-block #({tag 1:575}) 575 600})
  load-frame-offset	#t, N23/edx, -4
  load-frame-offset	#t, G22/ecx, -1
  bne	{tag 13:450}, eax, {constant "KPfalseVKi"}

#({tag 1:575}) [575->600] (level:1) is #f with stack state #f
#({basic-block #() 600 600})
  load-frame-offset	#t, G30/edi, -3
  load-frame-offset	#t, G29/eax, -2
  push	G30/edi
  move	eax, G29/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [600->600] (level:1) is #f with stack state #f
#({basic-block #() 600 605})

#() [600->605] (level:1) is #f with stack state #f
#()
  rts	

#({tag 4:225}) [225->235] (level:3) is #f with stack state #f
#({basic-block #({tag 8:245}) 245 250})
  ld	G16/eax, esi, 0
  move	N18/edi, N8/edx

#({tag 8:245}) [245->250] (level:4) is #f with stack state #f
#({basic-block #({tag 3:270}, {tag 10:270}) 270 285}, {basic-block #({tag 7:235}) 235 240})
  bhi	{tag 3:270}, N18/edi, N9/ebx

#({tag 7:235}) [235->240] (level:3) is #f with stack state #f
#({basic-block #() 240 245}, {basic-block #({tag 9:250}) 250 270})
  beq-mem	{tag 9:250}, N18/edi, 0, G16/eax

#() [240->245] (level:2) is #f with stack state #f
#({basic-block #({tag 8:245}) 245 250})
  add	N18/edi, N18/edi, 8

#() [610->615] (level:0) is #f with stack state #f
#()
  bra	{tag 8:245}

#({tag 17:415}) [415->435] (level:1) is #f with stack state #f
#({basic-block #({tag 16:435}) 435 445})
  ld	N24/ebx, G25/edi, 4
  push	G25/edi
  move	eax, eax
  call	N24/ebx, 1

#() [615->620] (level:0) is #f with stack state #f
#()
  bra	{tag 16:435}

#({tag 14:545}) [545->570] (level:3) is #f with stack state #f
#({basic-block #() 570 575})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#() [570->575] (level:3) is #f with stack state #f
#()
  jmp-indirect	ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 19:510}) [510->530] (level:2) is #f with stack state #f
#({basic-block #({tag 18:530}) 530 545})
  ld	N27/ebx, G28/edi, 4
  push	G28/edi
  move	eax, G21/eax
  call	N27/ebx, 1

#() [620->625] (level:0) is #f with stack state #f
#()
  bra	{tag 18:530}

#({tag 9:250}) [250->270] (level:3) is #f with stack state #f
#({basic-block #({tag 3:270}, {tag 10:270}) 270 285})
  sub	N17/edi, N18/edi, N8/edx
  asr	N17/edi, N17/edi, 1
  ld	G15/eax, esi, 4
  st	G15/eax, ecx, N17/edi

#() [625->630] (level:0) is #f with stack state #f
#()
  bra	{tag 3:270}

+++ ending code for primitive_process_keys_checking_args_for_xep +++

+++ Live variable scopes for primitive_process_keys_checking_args_for_xep +++
Start scope at 83 with frame for no variables
End scope at 326

+++ No Source Code Locators for primitive_process_keys_checking_args_for_xep +++


+++ Exported function definition slotacc_single_q_instance_getter_xep +++

+++ starting code for slotacc_single_q_instance_getter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 2

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_single_q_instance_getterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_single_q_instance_getter_xep +++

+++ No Source Code Locators for slotacc_single_q_instance_getter_xep +++


+++ Exported function definition slotacc_single_q_instance_setter_xep +++

+++ starting code for slotacc_single_q_instance_setter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 3

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_single_q_instance_setterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_single_q_instance_setter_xep +++

+++ No Source Code Locators for slotacc_single_q_instance_setter_xep +++


+++ Exported function definition slotacc_single_q_class_getter_xep +++

+++ starting code for slotacc_single_q_class_getter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 2

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_single_q_class_getterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_single_q_class_getter_xep +++

+++ No Source Code Locators for slotacc_single_q_class_getter_xep +++


+++ Exported function definition slotacc_single_q_class_setter_xep +++

+++ starting code for slotacc_single_q_class_setter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 3

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_single_q_class_setterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_single_q_class_setter_xep +++

+++ No Source Code Locators for slotacc_single_q_class_setter_xep +++


+++ Exported function definition slotacc_repeated_instance_getter_xep +++

+++ starting code for slotacc_repeated_instance_getter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 3

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_repeated_instance_getterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_repeated_instance_getter_xep +++

+++ No Source Code Locators for slotacc_repeated_instance_getter_xep +++


+++ Exported function definition slotacc_repeated_instance_setter_xep +++

+++ starting code for slotacc_repeated_instance_setter_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55})
  bne	{tag 1:25}, ecx, 4

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp	{constant "KPslotacc_repeated_instance_setterVKiI"}, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:25}) [25->55] (level:0) is #f with stack state #f
#({basic-block #() 55 55})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

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

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

+++ ending code for slotacc_repeated_instance_setter_xep +++

+++ No Source Code Locators for slotacc_repeated_instance_setter_xep +++


+++ Exported function definition primitive_set_accessor_method_xep +++

+++ starting code for primitive_set_accessor_method_xep +++

#() [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 #f
#({basic-block #() 25 30}, {basic-block #({tag 1:50}) 50 55})
  move	G0/eax, eax
  load-stack-arg-n	#f, N2/edi, 0
  asr	N2/edi, N2/edi, 2
  beq	{tag 1:50}, N2/edi, 0

#() [25->30] (level:0) is green with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 2:55}) 55 60})
  beq	{tag 2:55}, N2/edi, 1

#() [30->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 3:60}) 60 65})
  beq	{tag 3:60}, N2/edi, 2

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 4:65}) 65 70})
  beq	{tag 4:65}, N2/edi, 3

#() [40->45] (level:0) is green with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 5:70}) 70 75})
  beq	{tag 5:70}, N2/edi, 4

#() [45->50] (level:0) is green with stack state #f
#({basic-block #({tag 1:50}) 50 55}, {basic-block #({tag 6:75}) 75 80})
  beq	{tag 6:75}, N2/edi, 5

#({tag 1:50}) [50->55] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_single_q_instance_getter_xep"}

#({tag 7:80}) [80->90] (level:0) is green with stack state #f
#({basic-block #() 90 95})
  st	N1/edi, G0/eax, 4
  move	eax, G0/eax

#() [90->95] (level:0) is green with stack state #f
#()
  rts-and-drop	4

#({tag 2:55}) [55->60] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_single_q_instance_setter_xep"}

#() [95->100] (level:0) is #f with stack state #f
#()
  bra	{tag 7:80}

#({tag 3:60}) [60->65] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_single_q_class_getter_xep"}

#() [100->105] (level:0) is #f with stack state #f
#()
  bra	{tag 7:80}

#({tag 4:65}) [65->70] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_single_q_class_setter_xep"}

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 7:80}

#({tag 5:70}) [70->75] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_repeated_instance_getter_xep"}

#() [110->115] (level:0) is #f with stack state #f
#()
  bra	{tag 7:80}

#({tag 6:75}) [75->80] (level:0) is green with stack state #f
#({basic-block #({tag 7:80}) 80 90})
  move	N1/edi, {constant "slotacc_repeated_instance_setter_xep"}

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

+++ ending code for primitive_set_accessor_method_xep +++

+++ No Source Code Locators for primitive_set_accessor_method_xep +++


+++ Exported function definition xep_0 +++

+++ starting code for xep_0 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 50})
  bne	{tag 1:20}, ecx, 0

#() [10->15] (level:0) is #f with stack state #f
#({basic-block #() 15 20})
  move	edi, {constant "KPfalseVKi"}

#() [15->20] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:20}) [20->50] (level:0) is #f with stack state #f
#({basic-block #() 50 50})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [50->50] (level:0) is #f with stack state #f
#({basic-block #() 50 55})

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

+++ ending code for xep_0 +++

+++ No Source Code Locators for xep_0 +++


+++ Exported function definition xep_1 +++

+++ starting code for xep_1 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:145}) 145 175})
  bne	{tag 1:145}, ecx, 1

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 140})
  move	edi, {constant "KPfalseVKi"}
  ld	G1/edx, ebx, 8
  ld	G1/edx, G1/edx, 8
  ld-index-scaled	esi, G1/edx, 0, 8
  beq	{tag 4:140}, esi, {constant "KLobjectGVKd"}

#() [35->85] (level:0) is #f with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110})
  move	G0/ecx, eax
  preserve-registers-entry	
  push	G1/edx
  push	G0/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G3/edi, esi
  bne	{tag 6:90}, G3/edi, {constant "KLobjectGVKd"}

#() [85->90] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:110}) [110->115] (level:0) is #f with stack state #f
#({basic-block #() 115 140}, {basic-block #({tag 3:180}, {tag 2:180}) 180 205})
  beq	{tag 3:180}, eax, {constant "KPfalseVKi"}

#() [115->140] (level:0) is #f with stack state #f
#({basic-block #({tag 4:140}) 140 140})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:140}) [140->140] (level:0) is #f with stack state #f
#({basic-block #({tag 4:140}) 140 145})

#({tag 4:140}) [140->145] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:145}) [145->175] (level:0) is #f with stack state #f
#({basic-block #() 175 175})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [175->175] (level:0) is #f with stack state #f
#({basic-block #() 175 180})

#() [175->180] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:90}) [90->110] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  ld	N2/ebx, G3/edi, 4
  push	G3/edi
  move	eax, G0/ecx
  call	N2/ebx, 1

#() [210->215] (level:0) is #f with stack state #f
#()
  bra	{tag 5:110}

#({tag 3:180}, {tag 2:180}) [180->205] (level:0) is #f with stack state #f
#({basic-block #() 205 205})
  load-frame-offset	#t, G6/edi, -3
  load-frame-offset	#t, G5/eax, -2
  push	G6/edi
  move	eax, G5/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [205->205] (level:0) is #f with stack state #f
#({basic-block #() 205 210})

#() [205->210] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_1 +++

+++ Live variable scopes for xep_1 +++
Start scope at 32 with frame for no variables
End scope at 62
Start scope at 63 no frame for no variables
End scope at 69

+++ No Source Code Locators for xep_1 +++


+++ Exported function definition xep_2 +++

+++ starting code for xep_2 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:270}) 270 300})
  bne	{tag 1:270}, ecx, 2

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 160})
  move	edi, {constant "KPfalseVKi"}
  ld	G1/edx, ebx, 8
  ld	G1/edx, G1/edx, 8
  ld-index-scaled	esi, G1/edx, 0, 8
  beq	{tag 4:140}, esi, {constant "KLobjectGVKd"}

#() [35->85] (level:0) is #f with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110})
  move	G0/ecx, eax
  preserve-registers-entry	
  push	G1/edx
  push	G0/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G3/edi, esi
  bne	{tag 6:90}, G3/edi, {constant "KLobjectGVKd"}

#() [85->90] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:110}) [110->115] (level:0) is #f with stack state #f
#({basic-block #() 115 140}, {basic-block #({tag 3:305}, {tag 2:305}) 305 330})
  beq	{tag 3:305}, eax, {constant "KPfalseVKi"}

#() [115->140] (level:0) is #f with stack state #f
#({basic-block #({tag 4:140}) 140 160})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:140}) [140->160] (level:0) is #f with stack state #f
#({basic-block #() 160 210}, {basic-block #({tag 7:265}) 265 265})
  ld	G5/edx, ebx, 8
  ld	G5/edx, G5/edx, 8
  ld-index-scaled	esi, G5/edx, 1, 8
  beq	{tag 7:265}, esi, {constant "KLobjectGVKd"}

#() [160->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215}, {basic-block #({tag 9:215}) 215 235})
  load-stack-arg-n	#t, G4/ecx, 0
  preserve-registers-entry	
  push	G5/edx
  push	G4/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G7/edi, esi
  bne	{tag 9:215}, G7/edi, {constant "KLobjectGVKd"}

#() [210->215] (level:0) is #f with stack state #f
#({basic-block #({tag 8:235}) 235 240})
  move	eax, {constant "KPtrueVKi"}

#({tag 8:235}) [235->240] (level:0) is #f with stack state #f
#({basic-block #() 240 265}, {basic-block #({tag 3:305}, {tag 2:305}) 305 330})
  beq	{tag 3:305}, eax, {constant "KPfalseVKi"}

#() [240->265] (level:0) is #f with stack state #f
#({basic-block #({tag 7:265}) 265 265})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 7:265}) [265->265] (level:0) is #f with stack state #f
#({basic-block #({tag 7:265}) 265 270})

#({tag 7:265}) [265->270] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:270}) [270->300] (level:0) is #f with stack state #f
#({basic-block #() 300 300})
  preserve-registers-entry	
  asl	N8/ecx, ecx, 2
  add	N8/ecx, N8/ecx, 1
  push	N8/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [300->300] (level:0) is #f with stack state #f
#({basic-block #() 300 305})

#() [300->305] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:90}) [90->110] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  ld	N2/ebx, G3/edi, 4
  push	G3/edi
  move	eax, G0/ecx
  call	N2/ebx, 1

#() [335->340] (level:0) is #f with stack state #f
#()
  bra	{tag 5:110}

#({tag 3:305}, {tag 2:305}) [305->330] (level:0) is #f with stack state #f
#({basic-block #() 330 330})
  load-frame-offset	#t, G10/edi, -3
  load-frame-offset	#t, G9/eax, -2
  push	G10/edi
  move	eax, G9/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [330->330] (level:0) is #f with stack state #f
#({basic-block #() 330 335})

#() [330->335] (level:0) is #f with stack state #f
#()
  rts	

#({tag 9:215}) [215->235] (level:0) is #f with stack state #f
#({basic-block #({tag 8:235}) 235 240})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G4/ecx
  call	N6/ebx, 1

#() [340->345] (level:0) is #f with stack state #f
#()
  bra	{tag 8:235}

+++ ending code for xep_2 +++

+++ Live variable scopes for xep_2 +++
Start scope at 32 with frame for no variables
End scope at 62
Start scope at 63 no frame for no variables
End scope at 87
Start scope at 88 with frame for no variables
End scope at 118
Start scope at 119 no frame for no variables
End scope at 125

+++ No Source Code Locators for xep_2 +++


+++ Exported function definition xep_3 +++

+++ starting code for xep_3 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:395}) 395 425})
  bne	{tag 1:395}, ecx, 3

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 160})
  move	edi, {constant "KPfalseVKi"}
  ld	G1/edx, ebx, 8
  ld	G1/edx, G1/edx, 8
  ld-index-scaled	esi, G1/edx, 0, 8
  beq	{tag 4:140}, esi, {constant "KLobjectGVKd"}

#() [35->85] (level:0) is #f with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110})
  move	G0/ecx, eax
  preserve-registers-entry	
  push	G1/edx
  push	G0/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G3/edi, esi
  bne	{tag 6:90}, G3/edi, {constant "KLobjectGVKd"}

#() [85->90] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:110}) [110->115] (level:0) is #f with stack state #f
#({basic-block #() 115 140}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455})
  beq	{tag 3:430}, eax, {constant "KPfalseVKi"}

#() [115->140] (level:0) is #f with stack state #f
#({basic-block #({tag 4:140}) 140 160})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:140}) [140->160] (level:0) is #f with stack state #f
#({basic-block #() 160 210}, {basic-block #({tag 7:265}) 265 285})
  ld	G5/edx, ebx, 8
  ld	G5/edx, G5/edx, 8
  ld-index-scaled	esi, G5/edx, 1, 8
  beq	{tag 7:265}, esi, {constant "KLobjectGVKd"}

#() [160->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215}, {basic-block #({tag 9:215}) 215 235})
  load-stack-arg-n	#t, G4/ecx, 0
  preserve-registers-entry	
  push	G5/edx
  push	G4/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G7/edi, esi
  bne	{tag 9:215}, G7/edi, {constant "KLobjectGVKd"}

#() [210->215] (level:0) is #f with stack state #f
#({basic-block #({tag 8:235}) 235 240})
  move	eax, {constant "KPtrueVKi"}

#({tag 8:235}) [235->240] (level:0) is #f with stack state #f
#({basic-block #() 240 265}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455})
  beq	{tag 3:430}, eax, {constant "KPfalseVKi"}

#() [240->265] (level:0) is #f with stack state #f
#({basic-block #({tag 7:265}) 265 285})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 7:265}) [265->285] (level:0) is #f with stack state #f
#({basic-block #() 285 335}, {basic-block #({tag 10:390}) 390 390})
  ld	G9/edx, ebx, 8
  ld	G9/edx, G9/edx, 8
  ld-index-scaled	esi, G9/edx, 2, 8
  beq	{tag 10:390}, esi, {constant "KLobjectGVKd"}

#() [285->335] (level:0) is #f with stack state #f
#({basic-block #() 335 340}, {basic-block #({tag 12:340}) 340 360})
  load-stack-arg-n	#t, G8/ecx, 1
  preserve-registers-entry	
  push	G9/edx
  push	G8/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G11/edi, esi
  bne	{tag 12:340}, G11/edi, {constant "KLobjectGVKd"}

#() [335->340] (level:0) is #f with stack state #f
#({basic-block #({tag 11:360}) 360 365})
  move	eax, {constant "KPtrueVKi"}

#({tag 11:360}) [360->365] (level:0) is #f with stack state #f
#({basic-block #() 365 390}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455})
  beq	{tag 3:430}, eax, {constant "KPfalseVKi"}

#() [365->390] (level:0) is #f with stack state #f
#({basic-block #({tag 10:390}) 390 390})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 10:390}) [390->390] (level:0) is #f with stack state #f
#({basic-block #({tag 10:390}) 390 395})

#({tag 10:390}) [390->395] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:395}) [395->425] (level:0) is #f with stack state #f
#({basic-block #() 425 425})
  preserve-registers-entry	
  asl	N12/ecx, ecx, 2
  add	N12/ecx, N12/ecx, 1
  push	N12/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [425->425] (level:0) is #f with stack state #f
#({basic-block #() 425 430})

#() [425->430] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:90}) [90->110] (level:0) is #f with stack state #f
#({basic-block #({tag 5:110}) 110 115})
  ld	N2/ebx, G3/edi, 4
  push	G3/edi
  move	eax, G0/ecx
  call	N2/ebx, 1

#() [460->465] (level:0) is #f with stack state #f
#()
  bra	{tag 5:110}

#({tag 3:430}, {tag 2:430}) [430->455] (level:0) is #f with stack state #f
#({basic-block #() 455 455})
  load-frame-offset	#t, G14/edi, -3
  load-frame-offset	#t, G13/eax, -2
  push	G14/edi
  move	eax, G13/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [455->455] (level:0) is #f with stack state #f
#({basic-block #() 455 460})

#() [455->460] (level:0) is #f with stack state #f
#()
  rts	

#({tag 9:215}) [215->235] (level:0) is #f with stack state #f
#({basic-block #({tag 8:235}) 235 240})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G4/ecx
  call	N6/ebx, 1

#() [465->470] (level:0) is #f with stack state #f
#()
  bra	{tag 8:235}

#({tag 12:340}) [340->360] (level:0) is #f with stack state #f
#({basic-block #({tag 11:360}) 360 365})
  ld	N10/ebx, G11/edi, 4
  push	G11/edi
  move	eax, G8/ecx
  call	N10/ebx, 1

#() [470->475] (level:0) is #f with stack state #f
#()
  bra	{tag 11:360}

+++ ending code for xep_3 +++

+++ Live variable scopes for xep_3 +++
Start scope at 36 with frame for no variables
End scope at 74
Start scope at 75 no frame for no variables
End scope at 99
Start scope at 100 with frame for no variables
End scope at 130
Start scope at 131 no frame for no variables
End scope at 155
Start scope at 156 with frame for no variables
End scope at 186
Start scope at 187 no frame for no variables
End scope at 193

+++ No Source Code Locators for xep_3 +++


+++ Exported function definition xep_4 +++

+++ starting code for xep_4 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 4

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 16
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_4 +++

+++ No Source Code Locators for xep_4 +++


+++ Exported function definition xep_5 +++

+++ starting code for xep_5 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 5

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 20
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_5 +++

+++ No Source Code Locators for xep_5 +++


+++ Exported function definition xep_6 +++

+++ starting code for xep_6 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 6

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 24
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_6 +++

+++ No Source Code Locators for xep_6 +++


+++ Exported function definition xep_7 +++

+++ starting code for xep_7 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 7

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 28
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_7 +++

+++ No Source Code Locators for xep_7 +++


+++ Exported function definition xep_8 +++

+++ starting code for xep_8 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 8

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 32
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_8 +++

+++ No Source Code Locators for xep_8 +++


+++ Exported function definition xep_9 +++

+++ starting code for xep_9 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65})
  bne	{tag 1:35}, ecx, 9

#() [10->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30})
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 36
  move	ecx, ecx

#() [25->30] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:35}) [35->65] (level:0) is #f with stack state #f
#({basic-block #() 65 65})
  preserve-registers-entry	
  asl	N0/ecx, ecx, 2
  add	N0/ecx, N0/ecx, 1
  push	N0/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [65->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})

#() [65->70] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep_9 +++

+++ No Source Code Locators for xep_9 +++


+++ Exported function definition xep +++

+++ starting code for xep +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 55}, {basic-block #({tag 1:65}) 65 95})
  ld	N0/edi, ebx, 8
  ld	N0/edi, N0/edi, 4
  asr	N0/edi, N0/edi, 2
  and	N0/edi, N0/edi, 255
  bne	{tag 1:65}, ecx, N0/edi

#() [30->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  move	edi, {constant "KPfalseVKi"}
  ld	N1/ecx, ebx, 8
  ld	N1/ecx, N1/ecx, 4
  and	N1/ecx, N1/ecx, 1020
  move	ecx, N1/ecx

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:65}) [65->95] (level:0) is #f with stack state #f
#({basic-block #() 95 95})
  preserve-registers-entry	
  asl	N2/ecx, ecx, 2
  add	N2/ecx, N2/ecx, 1
  push	N2/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [95->95] (level:0) is #f with stack state #f
#({basic-block #() 95 100})

#() [95->100] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for xep +++

+++ No Source Code Locators for xep +++


+++ Exported function definition rest_xep_0 +++

+++ starting code for rest_xep_0 +++

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

#() [5->15] (level:0) is #f with stack state #f
#({basic-block #({tag 6:25}) 25 90}, {basic-block #({tag 5:15}) 15 25})
  pop	esi
  bgt	{tag 5:15}, ecx, 0

#({tag 6:25}) [25->90] (level:0) is #f with stack state #f
#({basic-block #() 90 95})
  move	N1/eax, esp
  sub	esp, esp, 12
  push	esi
  asl	ecx, ecx, 2
  move	N0/edi, ecx
  add	ecx, ecx, 1
  st	ecx, N1/eax, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N1/eax, -8
  add	N0/edi, N0/edi, 12
  st	N0/edi, N1/eax, -12
  add	N2/eax, N1/eax, -8
  move	eax, N2/eax
  move	edi, {constant "KPfalseVKi"}

#() [90->95] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 5:15}) [15->25] (level:0) is #f with stack state #f
#({basic-block #({tag 6:25}) 25 90})
  st	eax, esp, -4
  sub	esp, esp, 4

#() [160->165] (level:0) is #f with stack state #f
#()
  bra	{tag 6:25}

+++ ending code for rest_xep_0 +++

+++ No Source Code Locators for rest_xep_0 +++


+++ Exported function definition rest_xep_1 +++

+++ starting code for rest_xep_1 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 110}, {basic-block #({tag 1:220}) 220 250})
  blo	{tag 1:220}, ecx, 1

#() [10->110] (level:0) is #f with stack state #f
#({basic-block #() 110 160}, {basic-block #({tag 4:215}) 215 215})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  st	esi, esp, 0
  add	N0/edx, N2/edx, 4
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -3
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	edi, {constant "KPfalseVKi"}
  ld	G5/edx, ebx, 8
  ld	G5/edx, G5/edx, 8
  ld-index-scaled	esi, G5/edx, 0, 8
  beq	{tag 4:215}, esi, {constant "KLobjectGVKd"}

#() [110->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165}, {basic-block #({tag 6:165}) 165 185})
  move	G4/ecx, eax
  preserve-registers-entry	
  push	G5/edx
  push	G4/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G7/edi, esi
  bne	{tag 6:165}, G7/edi, {constant "KLobjectGVKd"}

#() [160->165] (level:0) is #f with stack state #f
#({basic-block #({tag 5:185}) 185 190})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:185}) [185->190] (level:0) is #f with stack state #f
#({basic-block #() 190 215}, {basic-block #({tag 3:255}, {tag 2:255}) 255 280})
  beq	{tag 3:255}, eax, {constant "KPfalseVKi"}

#() [190->215] (level:0) is #f with stack state #f
#({basic-block #({tag 4:215}) 215 215})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:215}) [215->215] (level:0) is #f with stack state #f
#({basic-block #({tag 4:215}) 215 220})

#({tag 4:215}) [215->220] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:220}) [220->250] (level:0) is #f with stack state #f
#({basic-block #() 250 250})
  preserve-registers-entry	
  asl	N8/ecx, ecx, 2
  add	N8/ecx, N8/ecx, 1
  push	N8/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [250->250] (level:0) is #f with stack state #f
#({basic-block #() 250 255})

#() [250->255] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:165}) [165->185] (level:0) is #f with stack state #f
#({basic-block #({tag 5:185}) 185 190})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G4/ecx
  call	N6/ebx, 1

#() [285->290] (level:0) is #f with stack state #f
#()
  bra	{tag 5:185}

#({tag 3:255}, {tag 2:255}) [255->280] (level:0) is #f with stack state #f
#({basic-block #() 280 280})
  load-frame-offset	#t, G10/edi, -3
  load-frame-offset	#t, G9/eax, -2
  push	G10/edi
  move	eax, G9/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [280->280] (level:0) is #f with stack state #f
#({basic-block #() 280 285})

#() [280->285] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_1 +++

+++ Live variable scopes for rest_xep_1 +++
Start scope at 79 with frame for no variables
End scope at 109
Start scope at 110 no frame for no variables
End scope at 116

+++ No Source Code Locators for rest_xep_1 +++


+++ Exported function definition rest_xep_2 +++

+++ starting code for rest_xep_2 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 120}, {basic-block #({tag 1:355}) 355 385})
  blo	{tag 1:355}, ecx, 2

#() [10->120] (level:0) is #f with stack state #f
#({basic-block #() 120 170}, {basic-block #({tag 4:225}) 225 245})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  add	N0/edx, N2/edx, 8
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -7
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	edi, {constant "KPfalseVKi"}
  ld	G5/edx, ebx, 8
  ld	G5/edx, G5/edx, 8
  ld-index-scaled	esi, G5/edx, 0, 8
  beq	{tag 4:225}, esi, {constant "KLobjectGVKd"}

#() [120->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175}, {basic-block #({tag 6:175}) 175 195})
  move	G4/ecx, eax
  preserve-registers-entry	
  push	G5/edx
  push	G4/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G7/edi, esi
  bne	{tag 6:175}, G7/edi, {constant "KLobjectGVKd"}

#() [170->175] (level:0) is #f with stack state #f
#({basic-block #({tag 5:195}) 195 200})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:195}) [195->200] (level:0) is #f with stack state #f
#({basic-block #() 200 225}, {basic-block #({tag 3:390}, {tag 2:390}) 390 415})
  beq	{tag 3:390}, eax, {constant "KPfalseVKi"}

#() [200->225] (level:0) is #f with stack state #f
#({basic-block #({tag 4:225}) 225 245})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:225}) [225->245] (level:0) is #f with stack state #f
#({basic-block #() 245 295}, {basic-block #({tag 7:350}) 350 350})
  ld	G9/edx, ebx, 8
  ld	G9/edx, G9/edx, 8
  ld-index-scaled	esi, G9/edx, 1, 8
  beq	{tag 7:350}, esi, {constant "KLobjectGVKd"}

#() [245->295] (level:0) is #f with stack state #f
#({basic-block #() 295 300}, {basic-block #({tag 9:300}) 300 320})
  load-stack-arg-n	#t, G8/ecx, 0
  preserve-registers-entry	
  push	G9/edx
  push	G8/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G11/edi, esi
  bne	{tag 9:300}, G11/edi, {constant "KLobjectGVKd"}

#() [295->300] (level:0) is #f with stack state #f
#({basic-block #({tag 8:320}) 320 325})
  move	eax, {constant "KPtrueVKi"}

#({tag 8:320}) [320->325] (level:0) is #f with stack state #f
#({basic-block #() 325 350}, {basic-block #({tag 3:390}, {tag 2:390}) 390 415})
  beq	{tag 3:390}, eax, {constant "KPfalseVKi"}

#() [325->350] (level:0) is #f with stack state #f
#({basic-block #({tag 7:350}) 350 350})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 7:350}) [350->350] (level:0) is #f with stack state #f
#({basic-block #({tag 7:350}) 350 355})

#({tag 7:350}) [350->355] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:355}) [355->385] (level:0) is #f with stack state #f
#({basic-block #() 385 385})
  preserve-registers-entry	
  asl	N12/ecx, ecx, 2
  add	N12/ecx, N12/ecx, 1
  push	N12/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [385->385] (level:0) is #f with stack state #f
#({basic-block #() 385 390})

#() [385->390] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:175}) [175->195] (level:0) is #f with stack state #f
#({basic-block #({tag 5:195}) 195 200})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G4/ecx
  call	N6/ebx, 1

#() [420->425] (level:0) is #f with stack state #f
#()
  bra	{tag 5:195}

#({tag 3:390}, {tag 2:390}) [390->415] (level:0) is #f with stack state #f
#({basic-block #() 415 415})
  load-frame-offset	#t, G14/edi, -3
  load-frame-offset	#t, G13/eax, -2
  push	G14/edi
  move	eax, G13/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [415->415] (level:0) is #f with stack state #f
#({basic-block #() 415 420})

#() [415->420] (level:0) is #f with stack state #f
#()
  rts	

#({tag 9:300}) [300->320] (level:0) is #f with stack state #f
#({basic-block #({tag 8:320}) 320 325})
  ld	N10/ebx, G11/edi, 4
  push	G11/edi
  move	eax, G8/ecx
  call	N10/ebx, 1

#() [425->430] (level:0) is #f with stack state #f
#()
  bra	{tag 8:320}

+++ ending code for rest_xep_2 +++

+++ Live variable scopes for rest_xep_2 +++
Start scope at 90 with frame for no variables
End scope at 120
Start scope at 121 no frame for no variables
End scope at 145
Start scope at 146 with frame for no variables
End scope at 176
Start scope at 177 no frame for no variables
End scope at 183

+++ No Source Code Locators for rest_xep_2 +++


+++ Exported function definition rest_xep_3 +++

+++ starting code for rest_xep_3 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 130}, {basic-block #({tag 1:490}) 490 520})
  blo	{tag 1:490}, ecx, 3

#() [10->130] (level:0) is #f with stack state #f
#({basic-block #() 130 180}, {basic-block #({tag 4:235}) 235 255})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edx, 8
  st	esi, esp, 8
  add	N0/edx, N2/edx, 12
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -11
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	edi, {constant "KPfalseVKi"}
  ld	G5/edx, ebx, 8
  ld	G5/edx, G5/edx, 8
  ld-index-scaled	esi, G5/edx, 0, 8
  beq	{tag 4:235}, esi, {constant "KLobjectGVKd"}

#() [130->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185}, {basic-block #({tag 6:185}) 185 205})
  move	G4/ecx, eax
  preserve-registers-entry	
  push	G5/edx
  push	G4/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G7/edi, esi
  bne	{tag 6:185}, G7/edi, {constant "KLobjectGVKd"}

#() [180->185] (level:0) is #f with stack state #f
#({basic-block #({tag 5:205}) 205 210})
  move	eax, {constant "KPtrueVKi"}

#({tag 5:205}) [205->210] (level:0) is #f with stack state #f
#({basic-block #() 210 235}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550})
  beq	{tag 3:525}, eax, {constant "KPfalseVKi"}

#() [210->235] (level:0) is #f with stack state #f
#({basic-block #({tag 4:235}) 235 255})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 4:235}) [235->255] (level:0) is #f with stack state #f
#({basic-block #() 255 305}, {basic-block #({tag 7:360}) 360 380})
  ld	G9/edx, ebx, 8
  ld	G9/edx, G9/edx, 8
  ld-index-scaled	esi, G9/edx, 1, 8
  beq	{tag 7:360}, esi, {constant "KLobjectGVKd"}

#() [255->305] (level:0) is #f with stack state #f
#({basic-block #() 305 310}, {basic-block #({tag 9:310}) 310 330})
  load-stack-arg-n	#t, G8/ecx, 0
  preserve-registers-entry	
  push	G9/edx
  push	G8/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G11/edi, esi
  bne	{tag 9:310}, G11/edi, {constant "KLobjectGVKd"}

#() [305->310] (level:0) is #f with stack state #f
#({basic-block #({tag 8:330}) 330 335})
  move	eax, {constant "KPtrueVKi"}

#({tag 8:330}) [330->335] (level:0) is #f with stack state #f
#({basic-block #() 335 360}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550})
  beq	{tag 3:525}, eax, {constant "KPfalseVKi"}

#() [335->360] (level:0) is #f with stack state #f
#({basic-block #({tag 7:360}) 360 380})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 7:360}) [360->380] (level:0) is #f with stack state #f
#({basic-block #() 380 430}, {basic-block #({tag 10:485}) 485 485})
  ld	G13/edx, ebx, 8
  ld	G13/edx, G13/edx, 8
  ld-index-scaled	esi, G13/edx, 2, 8
  beq	{tag 10:485}, esi, {constant "KLobjectGVKd"}

#() [380->430] (level:0) is #f with stack state #f
#({basic-block #() 430 435}, {basic-block #({tag 12:435}) 435 455})
  load-stack-arg-n	#t, G12/ecx, 1
  preserve-registers-entry	
  push	G13/edx
  push	G12/ecx
  push	esi
  push	eax
  push	ebx
  push	edi
  move	G15/edi, esi
  bne	{tag 12:435}, G15/edi, {constant "KLobjectGVKd"}

#() [430->435] (level:0) is #f with stack state #f
#({basic-block #({tag 11:455}) 455 460})
  move	eax, {constant "KPtrueVKi"}

#({tag 11:455}) [455->460] (level:0) is #f with stack state #f
#({basic-block #() 460 485}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550})
  beq	{tag 3:525}, eax, {constant "KPfalseVKi"}

#() [460->485] (level:0) is #f with stack state #f
#({basic-block #({tag 10:485}) 485 485})
  pop	edi
  pop	ebx
  pop	eax
  rem	"eliminated"
  preserve-registers-exit	

#({tag 10:485}) [485->485] (level:0) is #f with stack state #f
#({basic-block #({tag 10:485}) 485 490})

#({tag 10:485}) [485->490] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:490}) [490->520] (level:0) is #f with stack state #f
#({basic-block #() 520 520})
  preserve-registers-entry	
  asl	N16/ecx, ecx, 2
  add	N16/ecx, N16/ecx, 1
  push	N16/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [520->520] (level:0) is #f with stack state #f
#({basic-block #() 520 525})

#() [520->525] (level:0) is #f with stack state #f
#()
  rts	

#({tag 6:185}) [185->205] (level:0) is #f with stack state #f
#({basic-block #({tag 5:205}) 205 210})
  ld	N6/ebx, G7/edi, 4
  push	G7/edi
  move	eax, G4/ecx
  call	N6/ebx, 1

#() [555->560] (level:0) is #f with stack state #f
#()
  bra	{tag 5:205}

#({tag 3:525}, {tag 2:525}) [525->550] (level:0) is #f with stack state #f
#({basic-block #() 550 550})
  load-frame-offset	#t, G18/edi, -3
  load-frame-offset	#t, G17/eax, -2
  push	G18/edi
  move	eax, G17/eax
  call	{constant "Ktype_check_errorVKiI"}, 1

#() [550->550] (level:0) is #f with stack state #f
#({basic-block #() 550 555})

#() [550->555] (level:0) is #f with stack state #f
#()
  rts	

#({tag 9:310}) [310->330] (level:0) is #f with stack state #f
#({basic-block #({tag 8:330}) 330 335})
  ld	N10/ebx, G11/edi, 4
  push	G11/edi
  move	eax, G8/ecx
  call	N10/ebx, 1

#() [560->565] (level:0) is #f with stack state #f
#()
  bra	{tag 8:330}

#({tag 12:435}) [435->455] (level:0) is #f with stack state #f
#({basic-block #({tag 11:455}) 455 460})
  ld	N14/ebx, G15/edi, 4
  push	G15/edi
  move	eax, G12/ecx
  call	N14/ebx, 1

#() [565->570] (level:0) is #f with stack state #f
#()
  bra	{tag 11:455}

+++ ending code for rest_xep_3 +++

+++ Live variable scopes for rest_xep_3 +++
Start scope at 97 with frame for no variables
End scope at 135
Start scope at 136 no frame for no variables
End scope at 160
Start scope at 161 with frame for no variables
End scope at 191
Start scope at 192 no frame for no variables
End scope at 216
Start scope at 217 with frame for no variables
End scope at 247
Start scope at 248 no frame for no variables
End scope at 254

+++ No Source Code Locators for rest_xep_3 +++


+++ Exported function definition rest_xep_4 +++

+++ starting code for rest_xep_4 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 130}, {basic-block #({tag 1:140}) 140 170})
  blo	{tag 1:140}, ecx, 4

#() [10->130] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edx, 8
  ld	ecx, N2/edx, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  add	N0/edx, N2/edx, 16
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -15
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 16
  move	ecx, ecx

#() [130->135] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:140}) [140->170] (level:0) is #f with stack state #f
#({basic-block #() 170 170})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [170->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175})

#() [170->175] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_4 +++

+++ No Source Code Locators for rest_xep_4 +++


+++ Exported function definition rest_xep_5 +++

+++ starting code for rest_xep_5 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 140}, {basic-block #({tag 1:150}) 150 180})
  blo	{tag 1:150}, ecx, 5

#() [10->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  st	esi, esp, 16
  add	N0/edi, N2/edi, 20
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -19
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 20
  move	ecx, ecx

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:150}) [150->180] (level:0) is #f with stack state #f
#({basic-block #() 180 180})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [180->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})

#() [180->185] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_5 +++

+++ No Source Code Locators for rest_xep_5 +++


+++ Exported function definition rest_xep_6 +++

+++ starting code for rest_xep_6 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 150}, {basic-block #({tag 1:160}) 160 190})
  blo	{tag 1:160}, ecx, 6

#() [10->150] (level:0) is #f with stack state #f
#({basic-block #() 150 155})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  ld	ecx, N2/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  add	N0/edi, N2/edi, 24
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -23
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 24
  move	ecx, ecx

#() [150->155] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:160}) [160->190] (level:0) is #f with stack state #f
#({basic-block #() 190 190})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [190->190] (level:0) is #f with stack state #f
#({basic-block #() 190 195})

#() [190->195] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_6 +++

+++ No Source Code Locators for rest_xep_6 +++


+++ Exported function definition rest_xep_7 +++

+++ starting code for rest_xep_7 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 160}, {basic-block #({tag 1:170}) 170 200})
  blo	{tag 1:170}, ecx, 7

#() [10->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  ld	ecx, N2/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N2/edi, 24
  st	esi, esp, 24
  add	N0/edi, N2/edi, 28
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -27
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 28
  move	ecx, ecx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:170}) [170->200] (level:0) is #f with stack state #f
#({basic-block #() 200 200})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [200->200] (level:0) is #f with stack state #f
#({basic-block #() 200 205})

#() [200->205] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_7 +++

+++ No Source Code Locators for rest_xep_7 +++


+++ Exported function definition rest_xep_8 +++

+++ starting code for rest_xep_8 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 170}, {basic-block #({tag 1:180}) 180 210})
  blo	{tag 1:180}, ecx, 8

#() [10->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  ld	ecx, N2/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N2/edi, 24
  ld	ecx, N2/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  add	N0/edi, N2/edi, 32
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -31
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 32
  move	ecx, ecx

#() [170->175] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:180}) [180->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_8 +++

+++ No Source Code Locators for rest_xep_8 +++


+++ Exported function definition rest_xep_9 +++

+++ starting code for rest_xep_9 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 180}, {basic-block #({tag 1:190}) 190 220})
  blo	{tag 1:190}, ecx, 9

#() [10->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  ld	ecx, N2/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N2/edi, 24
  ld	ecx, N2/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  ld	esi, N2/edi, 32
  st	esi, esp, 32
  add	N0/edi, N2/edi, 36
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -35
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	edi, {constant "KPfalseVKi"}
  move	ecx, 36
  move	ecx, ecx

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:190}) [190->220] (level:0) is #f with stack state #f
#({basic-block #() 220 220})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [220->220] (level:0) is #f with stack state #f
#({basic-block #() 220 225})

#() [220->225] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep_9 +++

+++ No Source Code Locators for rest_xep_9 +++


+++ Exported function definition rest_xep +++

+++ starting code for rest_xep +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 185}, {basic-block #({tag 1:195}) 195 225})
  ld	N0/edi, ebx, 8
  ld	N0/edi, N0/edi, 4
  asr	N0/edi, N0/edi, 2
  and	N0/edi, N0/edi, 255
  blo	{tag 1:195}, ecx, N0/edi

#() [30->185] (level:0) is #f with stack state #f
#({basic-block #() 185 190})
  ld	N3/edi, ebx, 8
  ld	N3/edi, N3/edi, 4
  asr	N3/edi, N3/edi, 2
  and	N3/edi, N3/edi, 255
  move	esi, esp
  sub	esp, esp, 16
  move	N2/edx, ecx
  move	ecx, N3/edi
  move	N4/edi, esp
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N1/edi, esi
  asl	N2/edx, N2/edx, 2
  move	ecx, N2/edx
  ld	esi, ebx, 8
  ld	esi, esi, 4
  and	esi, esi, 1020
  sub	N2/edx, N2/edx, esi
  add	N2/edx, N2/edx, 1
  st	N2/edx, N1/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8
  add	ecx, ecx, 12
  st	ecx, N1/edi, -12
  add	N5/edx, N1/edi, -8
  st	N5/edx, N1/edi, -16
  move	edi, {constant "KPfalseVKi"}
  ld	N6/ecx, ebx, 8
  ld	N6/ecx, N6/ecx, 4
  and	N6/ecx, N6/ecx, 1020
  move	ecx, N6/ecx

#() [185->190] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f

#({tag 1:195}) [195->225] (level:0) is #f with stack state #f
#({basic-block #() 225 225})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [225->225] (level:0) is #f with stack state #f
#({basic-block #() 225 230})

#() [225->230] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_xep +++

+++ No Source Code Locators for rest_xep +++


+++ Exported function definition rest_key_xep_0 +++

+++ starting code for rest_key_xep_0 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #({tag 6:40}) 40 160}, {basic-block #({tag 5:30}) 30 40})
  ld	N2/edx, ebx, 20
  ld	N0/edx, N2/edx, 4
  asr	N0/edx, N0/edx, 3
  pop	esi
  bgt	{tag 5:30}, ecx, 0

#({tag 6:40}) [40->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  add	N5/edx, N0/edx, 3
  asl	N5/edx, N5/edx, 2
  move	N4/edi, esp
  sub	esp, esp, N5/edx
  push	esi
  asl	ecx, ecx, 2
  move	N3/eax, ecx
  add	ecx, ecx, 1
  st	ecx, N4/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N4/edi, -8
  ld	N7/edx, ebx, 20
  ld	N6/edx, N7/edx, 4
  asr	N6/edx, N6/edx, 3
  add	N8/edx, N6/edx, 3
  asl	N8/edx, N8/edx, 2
  add	N3/eax, N3/eax, N8/edx
  st	N3/eax, N4/edi, -12
  add	N9/edi, N4/edi, -8
  move	eax, N9/edi
  sub	N1/ecx, N9/edi, 8
  move	ecx, N1/ecx
  move	esi, N9/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 5:30}) [30->40] (level:0) is #f with stack state #f
#({basic-block #({tag 6:40}) 40 160})
  st	eax, esp, -4
  sub	esp, esp, 4

#() [240->245] (level:0) is #f with stack state #f
#()
  bra	{tag 6:40}

+++ ending code for rest_key_xep_0 +++

+++ No Source Code Locators for rest_key_xep_0 +++


+++ Exported function definition rest_key_xep_1 +++

+++ starting code for rest_key_xep_1 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 170}, {basic-block #({tag 1:310}) 310 340})
  blo	{tag 1:310}, ecx, 1

#() [10->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edx, esp, N6/edi
  move	N4/edi, ecx
  ld	esi, N5/edx, 0
  st	esi, esp, 0
  add	N3/edx, N5/edx, 4
  asl	N4/edi, N4/edi, 2
  move	ecx, N4/edi
  add	N4/edi, N4/edi, -3
  st	N4/edi, N3/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8
  ld	N8/edi, ebx, 20
  ld	N7/edi, N8/edi, 4
  asr	N7/edi, N7/edi, 3
  add	N9/edi, N7/edi, 4
  asl	N9/edi, N9/edi, 2
  add	ecx, ecx, N9/edi
  sub	ecx, ecx, 4
  st	ecx, N3/edx, -12
  sub	esi, N3/edx, N9/edi
  add	N10/edx, N3/edx, -8
  st	N10/edx, esi, 0
  sub	N1/ecx, N10/edx, 8
  move	ecx, N1/ecx
  move	esi, N10/edx
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [170->175] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:310}) [310->340] (level:0) is #f with stack state #f
#({basic-block #() 340 340})
  preserve-registers-entry	
  asl	N15/ecx, ecx, 2
  add	N15/ecx, N15/ecx, 1
  push	N15/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [340->340] (level:0) is #f with stack state #f
#({basic-block #() 340 345})

#() [340->345] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_1 +++

+++ No Source Code Locators for rest_key_xep_1 +++


+++ Exported function definition rest_key_xep_2 +++

+++ starting code for rest_key_xep_2 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 180}, {basic-block #({tag 1:445}) 445 475})
  blo	{tag 1:445}, ecx, 2

#() [10->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N2/edx, ebx, 20
  ld	N0/edx, N2/edx, 4
  asr	N0/edx, N0/edx, 3
  add	N6/edx, N0/edx, 4
  asl	N6/edx, N6/edx, 2
  sub	esp, esp, N6/edx
  add	N5/edx, esp, N6/edx
  move	N4/edi, ecx
  ld	esi, N5/edx, 0
  ld	ecx, N5/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  add	N3/edx, N5/edx, 8
  asl	N4/edi, N4/edi, 2
  move	ecx, N4/edi
  add	N4/edi, N4/edi, -7
  st	N4/edi, N3/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8
  ld	N8/edi, ebx, 20
  ld	N7/edi, N8/edi, 4
  asr	N7/edi, N7/edi, 3
  add	N9/edi, N7/edi, 4
  asl	N9/edi, N9/edi, 2
  add	ecx, ecx, N9/edi
  sub	ecx, ecx, 4
  st	ecx, N3/edx, -12
  sub	esi, N3/edx, N9/edi
  add	N10/edx, N3/edx, -8
  st	N10/edx, esi, 0
  sub	N1/ecx, N10/edx, 8
  move	ecx, N1/ecx
  move	esi, N10/edx
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:445}) [445->475] (level:0) is #f with stack state #f
#({basic-block #() 475 475})
  preserve-registers-entry	
  asl	N19/ecx, ecx, 2
  add	N19/ecx, N19/ecx, 1
  push	N19/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [475->475] (level:0) is #f with stack state #f
#({basic-block #() 475 480})

#() [475->480] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_2 +++

+++ No Source Code Locators for rest_key_xep_2 +++


+++ Exported function definition rest_key_xep_3 +++

+++ starting code for rest_key_xep_3 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 190}, {basic-block #({tag 1:580}) 580 610})
  blo	{tag 1:580}, ecx, 3

#() [10->190] (level:0) is #f with stack state #f
#({basic-block #() 190 195})
  ld	N2/edx, ebx, 20
  ld	N0/edx, N2/edx, 4
  asr	N0/edx, N0/edx, 3
  add	N6/edx, N0/edx, 4
  asl	N6/edx, N6/edx, 2
  sub	esp, esp, N6/edx
  add	N5/edx, esp, N6/edx
  move	N4/edi, ecx
  ld	esi, N5/edx, 0
  ld	ecx, N5/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edx, 8
  st	esi, esp, 8
  add	N3/edx, N5/edx, 12
  asl	N4/edi, N4/edi, 2
  move	ecx, N4/edi
  add	N4/edi, N4/edi, -11
  st	N4/edi, N3/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8
  ld	N8/edi, ebx, 20
  ld	N7/edi, N8/edi, 4
  asr	N7/edi, N7/edi, 3
  add	N9/edi, N7/edi, 4
  asl	N9/edi, N9/edi, 2
  add	ecx, ecx, N9/edi
  sub	ecx, ecx, 4
  st	ecx, N3/edx, -12
  sub	esi, N3/edx, N9/edi
  add	N10/edx, N3/edx, -8
  st	N10/edx, esi, 0
  sub	N1/ecx, N10/edx, 8
  move	ecx, N1/ecx
  move	esi, N10/edx
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [190->195] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:580}) [580->610] (level:0) is #f with stack state #f
#({basic-block #() 610 610})
  preserve-registers-entry	
  asl	N23/ecx, ecx, 2
  add	N23/ecx, N23/ecx, 1
  push	N23/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [610->610] (level:0) is #f with stack state #f
#({basic-block #() 610 615})

#() [610->615] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_3 +++

+++ No Source Code Locators for rest_key_xep_3 +++


+++ Exported function definition rest_key_xep_4 +++

+++ starting code for rest_key_xep_4 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 200}, {basic-block #({tag 1:230}) 230 260})
  blo	{tag 1:230}, ecx, 4

#() [10->200] (level:0) is #f with stack state #f
#({basic-block #() 200 205})
  ld	N2/edx, ebx, 20
  ld	N0/edx, N2/edx, 4
  asr	N0/edx, N0/edx, 3
  add	N6/edx, N0/edx, 4
  asl	N6/edx, N6/edx, 2
  sub	esp, esp, N6/edx
  add	N5/edx, esp, N6/edx
  move	N4/edi, ecx
  ld	esi, N5/edx, 0
  ld	ecx, N5/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edx, 8
  ld	ecx, N5/edx, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  add	N3/edx, N5/edx, 16
  asl	N4/edi, N4/edi, 2
  move	ecx, N4/edi
  add	N4/edi, N4/edi, -15
  st	N4/edi, N3/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8
  ld	N8/edi, ebx, 20
  ld	N7/edi, N8/edi, 4
  asr	N7/edi, N7/edi, 3
  add	N9/edi, N7/edi, 4
  asl	N9/edi, N9/edi, 2
  add	ecx, ecx, N9/edi
  sub	ecx, ecx, 4
  st	ecx, N3/edx, -12
  sub	esi, N3/edx, N9/edi
  add	N10/edx, N3/edx, -8
  st	N10/edx, esi, 0
  sub	N1/ecx, N10/edx, 8
  move	ecx, N1/ecx
  move	esi, N10/edx
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [200->205] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:230}) [230->260] (level:0) is #f with stack state #f
#({basic-block #() 260 260})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [260->260] (level:0) is #f with stack state #f
#({basic-block #() 260 265})

#() [260->265] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_4 +++

+++ No Source Code Locators for rest_key_xep_4 +++


+++ Exported function definition rest_key_xep_5 +++

+++ starting code for rest_key_xep_5 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 210}, {basic-block #({tag 1:240}) 240 270})
  blo	{tag 1:240}, ecx, 5

#() [10->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edi, esp, N6/edi
  move	N4/edx, ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  st	esi, esp, 16
  add	N3/edi, N5/edi, 20
  asl	N4/edx, N4/edx, 2
  move	ecx, N4/edx
  add	N4/edx, N4/edx, -19
  st	N4/edx, N3/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8
  ld	N8/edx, ebx, 20
  ld	N7/edx, N8/edx, 4
  asr	N7/edx, N7/edx, 3
  add	N9/edx, N7/edx, 4
  asl	N9/edx, N9/edx, 2
  add	ecx, ecx, N9/edx
  sub	ecx, ecx, 4
  st	ecx, N3/edi, -12
  sub	esi, N3/edi, N9/edx
  add	N10/edi, N3/edi, -8
  st	N10/edi, esi, 0
  sub	N1/ecx, N10/edi, 8
  move	ecx, N1/ecx
  move	esi, N10/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [210->215] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:240}) [240->270] (level:0) is #f with stack state #f
#({basic-block #() 270 270})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [270->270] (level:0) is #f with stack state #f
#({basic-block #() 270 275})

#() [270->275] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_5 +++

+++ No Source Code Locators for rest_key_xep_5 +++


+++ Exported function definition rest_key_xep_6 +++

+++ starting code for rest_key_xep_6 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 220}, {basic-block #({tag 1:250}) 250 280})
  blo	{tag 1:250}, ecx, 6

#() [10->220] (level:0) is #f with stack state #f
#({basic-block #() 220 225})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edi, esp, N6/edi
  move	N4/edx, ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  add	N3/edi, N5/edi, 24
  asl	N4/edx, N4/edx, 2
  move	ecx, N4/edx
  add	N4/edx, N4/edx, -23
  st	N4/edx, N3/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8
  ld	N8/edx, ebx, 20
  ld	N7/edx, N8/edx, 4
  asr	N7/edx, N7/edx, 3
  add	N9/edx, N7/edx, 4
  asl	N9/edx, N9/edx, 2
  add	ecx, ecx, N9/edx
  sub	ecx, ecx, 4
  st	ecx, N3/edi, -12
  sub	esi, N3/edi, N9/edx
  add	N10/edi, N3/edi, -8
  st	N10/edi, esi, 0
  sub	N1/ecx, N10/edi, 8
  move	ecx, N1/ecx
  move	esi, N10/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [220->225] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:250}) [250->280] (level:0) is #f with stack state #f
#({basic-block #() 280 280})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [280->280] (level:0) is #f with stack state #f
#({basic-block #() 280 285})

#() [280->285] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_6 +++

+++ No Source Code Locators for rest_key_xep_6 +++


+++ Exported function definition rest_key_xep_7 +++

+++ starting code for rest_key_xep_7 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 230}, {basic-block #({tag 1:260}) 260 290})
  blo	{tag 1:260}, ecx, 7

#() [10->230] (level:0) is #f with stack state #f
#({basic-block #() 230 235})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edi, esp, N6/edi
  move	N4/edx, ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  st	esi, esp, 24
  add	N3/edi, N5/edi, 28
  asl	N4/edx, N4/edx, 2
  move	ecx, N4/edx
  add	N4/edx, N4/edx, -27
  st	N4/edx, N3/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8
  ld	N8/edx, ebx, 20
  ld	N7/edx, N8/edx, 4
  asr	N7/edx, N7/edx, 3
  add	N9/edx, N7/edx, 4
  asl	N9/edx, N9/edx, 2
  add	ecx, ecx, N9/edx
  sub	ecx, ecx, 4
  st	ecx, N3/edi, -12
  sub	esi, N3/edi, N9/edx
  add	N10/edi, N3/edi, -8
  st	N10/edi, esi, 0
  sub	N1/ecx, N10/edi, 8
  move	ecx, N1/ecx
  move	esi, N10/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [230->235] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:260}) [260->290] (level:0) is #f with stack state #f
#({basic-block #() 290 290})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [290->290] (level:0) is #f with stack state #f
#({basic-block #() 290 295})

#() [290->295] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_7 +++

+++ No Source Code Locators for rest_key_xep_7 +++


+++ Exported function definition rest_key_xep_8 +++

+++ starting code for rest_key_xep_8 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 240}, {basic-block #({tag 1:270}) 270 300})
  blo	{tag 1:270}, ecx, 8

#() [10->240] (level:0) is #f with stack state #f
#({basic-block #() 240 245})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edi, esp, N6/edi
  move	N4/edx, ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  ld	ecx, N5/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  add	N3/edi, N5/edi, 32
  asl	N4/edx, N4/edx, 2
  move	ecx, N4/edx
  add	N4/edx, N4/edx, -31
  st	N4/edx, N3/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8
  ld	N8/edx, ebx, 20
  ld	N7/edx, N8/edx, 4
  asr	N7/edx, N7/edx, 3
  add	N9/edx, N7/edx, 4
  asl	N9/edx, N9/edx, 2
  add	ecx, ecx, N9/edx
  sub	ecx, ecx, 4
  st	ecx, N3/edi, -12
  sub	esi, N3/edi, N9/edx
  add	N10/edi, N3/edi, -8
  st	N10/edi, esi, 0
  sub	N1/ecx, N10/edi, 8
  move	ecx, N1/ecx
  move	esi, N10/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [240->245] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:270}) [270->300] (level:0) is #f with stack state #f
#({basic-block #() 300 300})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [300->300] (level:0) is #f with stack state #f
#({basic-block #() 300 305})

#() [300->305] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_8 +++

+++ No Source Code Locators for rest_key_xep_8 +++


+++ Exported function definition rest_key_xep_9 +++

+++ starting code for rest_key_xep_9 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 250}, {basic-block #({tag 1:280}) 280 310})
  blo	{tag 1:280}, ecx, 9

#() [10->250] (level:0) is #f with stack state #f
#({basic-block #() 250 255})
  ld	N2/edi, ebx, 20
  ld	N0/edi, N2/edi, 4
  asr	N0/edi, N0/edi, 3
  add	N6/edi, N0/edi, 4
  asl	N6/edi, N6/edi, 2
  sub	esp, esp, N6/edi
  add	N5/edi, esp, N6/edi
  move	N4/edx, ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  ld	ecx, N5/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  ld	esi, N5/edi, 32
  st	esi, esp, 32
  add	N3/edi, N5/edi, 36
  asl	N4/edx, N4/edx, 2
  move	ecx, N4/edx
  add	N4/edx, N4/edx, -35
  st	N4/edx, N3/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8
  ld	N8/edx, ebx, 20
  ld	N7/edx, N8/edx, 4
  asr	N7/edx, N7/edx, 3
  add	N9/edx, N7/edx, 4
  asl	N9/edx, N9/edx, 2
  add	ecx, ecx, N9/edx
  sub	ecx, ecx, 4
  st	ecx, N3/edi, -12
  sub	esi, N3/edi, N9/edx
  add	N10/edi, N3/edi, -8
  st	N10/edi, esi, 0
  sub	N1/ecx, N10/edi, 8
  move	ecx, N1/ecx
  move	esi, N10/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [250->255] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:280}) [280->310] (level:0) is #f with stack state #f
#({basic-block #() 310 310})
  preserve-registers-entry	
  asl	N11/ecx, ecx, 2
  add	N11/ecx, N11/ecx, 1
  push	N11/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [310->310] (level:0) is #f with stack state #f
#({basic-block #() 310 315})

#() [310->315] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep_9 +++

+++ No Source Code Locators for rest_key_xep_9 +++


+++ Exported function definition rest_key_xep +++

+++ starting code for rest_key_xep +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 245}, {basic-block #({tag 1:285}) 285 315})
  ld	N0/edi, ebx, 8
  ld	N0/edi, N0/edi, 4
  asr	N0/edi, N0/edi, 2
  and	N0/edi, N0/edi, 255
  blo	{tag 1:285}, ecx, N0/edi

#() [30->245] (level:0) is #f with stack state #f
#({basic-block #() 245 250})
  ld	N3/edx, ebx, 20
  ld	N1/edx, N3/edx, 4
  asr	N1/edx, N1/edx, 3
  ld	N6/edi, ebx, 8
  ld	N6/edi, N6/edi, 4
  asr	N6/edi, N6/edi, 2
  and	N6/edi, N6/edi, 255
  add	N8/edx, N1/edx, 4
  asl	N8/edx, N8/edx, 2
  move	esi, esp
  sub	esp, esp, N8/edx
  move	N5/edx, ecx
  move	ecx, N6/edi
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N4/edi, esi
  asl	N5/edx, N5/edx, 2
  move	ecx, N5/edx
  ld	esi, ebx, 8
  ld	esi, esi, 4
  and	esi, esi, 1020
  sub	N5/edx, N5/edx, esi
  add	N5/edx, N5/edx, 1
  st	N5/edx, N4/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N4/edi, -8
  ld	N10/edx, ebx, 20
  ld	N9/edx, N10/edx, 4
  asr	N9/edx, N9/edx, 3
  add	N11/edx, N9/edx, 4
  asl	N11/edx, N11/edx, 2
  add	ecx, ecx, N11/edx
  sub	ecx, ecx, 4
  st	ecx, N4/edi, -12
  sub	esi, N4/edi, N11/edx
  add	N12/edi, N4/edi, -8
  st	N12/edi, esi, 0
  sub	N2/ecx, N12/edi, 8
  move	ecx, N2/ecx
  move	esi, N12/edi
  move	edi, {constant "KPfalseVKi"}
  move	ebx, ebx

#() [245->250] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

#({tag 1:285}) [285->315] (level:0) is #f with stack state #f
#({basic-block #() 315 315})
  preserve-registers-entry	
  asl	N14/ecx, ecx, 2
  add	N14/ecx, N14/ecx, 1
  push	N14/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [315->315] (level:0) is #f with stack state #f
#({basic-block #() 315 320})

#() [315->320] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for rest_key_xep +++

+++ No Source Code Locators for rest_key_xep +++


+++ Exported function definition rest_key_mep_0 +++

+++ starting code for rest_key_mep_0 +++

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

#() [5->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 4, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  st	esi, esp, 0
  add	N1/edi, N5/edi, 4
  sub	N3/ecx, N1/edi, 4
  move	N2/edi, eax
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_0 +++

+++ No Source Code Locators for rest_key_mep_0 +++


+++ Exported function definition rest_key_mep_1 +++

+++ starting code for rest_key_mep_1 +++

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

#() [5->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 8, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  add	N1/edi, N5/edi, 8
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 4
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_1 +++

+++ No Source Code Locators for rest_key_mep_1 +++


+++ Exported function definition rest_key_mep_2 +++

+++ starting code for rest_key_mep_2 +++

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

#() [5->120] (level:0) is #f with stack state #f
#({basic-block #() 120 125})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 12, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  st	esi, esp, 8
  add	N1/edi, N5/edi, 12
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 8
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [120->125] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_2 +++

+++ No Source Code Locators for rest_key_mep_2 +++


+++ Exported function definition rest_key_mep_3 +++

+++ starting code for rest_key_mep_3 +++

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

#() [5->130] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 16, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  add	N1/edi, N5/edi, 16
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 12
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [130->135] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_3 +++

+++ No Source Code Locators for rest_key_mep_3 +++


+++ Exported function definition rest_key_mep_4 +++

+++ starting code for rest_key_mep_4 +++

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

#() [5->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 20, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  st	esi, esp, 16
  add	N1/edi, N5/edi, 20
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 16
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_4 +++

+++ No Source Code Locators for rest_key_mep_4 +++


+++ Exported function definition rest_key_mep_5 +++

+++ starting code for rest_key_mep_5 +++

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

#() [5->150] (level:0) is #f with stack state #f
#({basic-block #() 150 155})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 24, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  add	N1/edi, N5/edi, 24
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 20
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [150->155] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_5 +++

+++ No Source Code Locators for rest_key_mep_5 +++


+++ Exported function definition rest_key_mep_6 +++

+++ starting code for rest_key_mep_6 +++

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

#() [5->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 28, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  st	esi, esp, 24
  add	N1/edi, N5/edi, 28
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 24
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_6 +++

+++ No Source Code Locators for rest_key_mep_6 +++


+++ Exported function definition rest_key_mep_7 +++

+++ starting code for rest_key_mep_7 +++

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

#() [5->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 32, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  ld	ecx, N5/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  add	N1/edi, N5/edi, 32
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 28
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [170->175] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_7 +++

+++ No Source Code Locators for rest_key_mep_7 +++


+++ Exported function definition rest_key_mep_8 +++

+++ starting code for rest_key_mep_8 +++

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

#() [5->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 36, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  ld	ecx, N5/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  ld	esi, N5/edi, 32
  st	esi, esp, 32
  add	N1/edi, N5/edi, 36
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 32
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_8 +++

+++ No Source Code Locators for rest_key_mep_8 +++


+++ Exported function definition rest_key_mep_9 +++

+++ starting code for rest_key_mep_9 +++

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

#() [5->190] (level:0) is #f with stack state #f
#({basic-block #() 190 195})
  move	N0/edx, edi
  ld	N4/ecx, ebx, 20
  ld	ecx, N4/ecx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  add2-mem	esp, 40, 0, esi
  move	N6/ecx, ecx
  asl	N6/ecx, N6/ecx, 2
  sub	esp, esp, N6/ecx
  add	N5/edi, esp, N6/ecx
  ld	esi, N5/edi, 0
  ld	ecx, N5/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N5/edi, 8
  ld	ecx, N5/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N5/edi, 16
  ld	ecx, N5/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  ld	esi, N5/edi, 24
  ld	ecx, N5/edi, 28
  st	esi, esp, 24
  st	ecx, esp, 28
  ld	esi, N5/edi, 32
  ld	ecx, N5/edi, 36
  st	esi, esp, 32
  st	ecx, esp, 36
  add	N1/edi, N5/edi, 40
  sub	N3/ecx, N1/edi, 4
  ld	N2/edi, esp, 36
  move	ecx, N3/ecx
  move	esi, N2/edi
  move	edi, N0/edx
  move	ebx, ebx

#() [190->195] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep_9 +++

+++ No Source Code Locators for rest_key_mep_9 +++


+++ Exported function definition rest_key_mep +++

+++ starting code for rest_key_mep +++

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

#() [5->155] (level:0) is #f with stack state #f
#({basic-block #() 155 160})
  push	edi
  push	ebx
  ld	N3/edi, ebx, 8
  ld	N3/edi, N3/edi, 4
  asr	N3/edi, N3/edi, 2
  and	N3/edi, N3/edi, 255
  add	N3/edi, N3/edi, 3
  ld	N4/ebx, ebx, 20
  ld	ecx, N4/ebx, 4
  asr	ecx, ecx, 3
  asl	esi, ecx, 2
  asl	N5/ebx, N3/edi, 2
  add2-mem	esp, N5/ebx, 0, esi
  move	N7/ecx, ecx
  asl	N7/ecx, N7/ecx, 2
  move	esi, esp
  sub	esp, esp, N7/ecx
  move	ecx, N3/edi
  move	N6/edi, esp
  move	edi, N6/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N0/ecx, esi
  sub	N2/ecx, N0/ecx, 4
  sub	N8/ebx, N5/ebx, 4
  ld	N1/ebx, esp, N8/ebx
  pop	ebx
  pop	edi
  move	ecx, N2/ecx
  move	esi, N1/ebx

#() [155->160] (level:0) is #f with stack state #f
#()
  jmp	{constant "primitive_process_keys"}, #[1, #"mlist", #"arg-count"], 0, #f, #f

+++ ending code for rest_key_mep +++

+++ No Source Code Locators for rest_key_mep +++


+++ Exported function definition new_gf_xep_0 +++

+++ starting code for new_gf_xep_0 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 0

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_0 +++

+++ No Source Code Locators for new_gf_xep_0 +++


+++ Exported function definition new_gf_xep_1 +++

+++ starting code for new_gf_xep_1 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 1

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_1 +++

+++ No Source Code Locators for new_gf_xep_1 +++


+++ Exported function definition new_gf_xep_2 +++

+++ starting code for new_gf_xep_2 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 2

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_2 +++

+++ No Source Code Locators for new_gf_xep_2 +++


+++ Exported function definition new_gf_xep_3 +++

+++ starting code for new_gf_xep_3 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 3

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_3 +++

+++ No Source Code Locators for new_gf_xep_3 +++


+++ Exported function definition new_gf_xep_4 +++

+++ starting code for new_gf_xep_4 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 4

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_4 +++

+++ No Source Code Locators for new_gf_xep_4 +++


+++ Exported function definition new_gf_xep_5 +++

+++ starting code for new_gf_xep_5 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 5

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_5 +++

+++ No Source Code Locators for new_gf_xep_5 +++


+++ Exported function definition new_gf_xep_6 +++

+++ starting code for new_gf_xep_6 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75})
  bne	{tag 1:45}, ecx, 6

#() [10->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G1/edi, ebx
  ld	G0/ebx, G1/edi, 24
  ld	N2/edx, G0/ebx, 12
  move	edi, G1/edi
  move	ebx, G0/ebx

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:45}) [45->75] (level:0) is #f with stack state #f
#({basic-block #() 75 75})
  preserve-registers-entry	
  asl	N3/ecx, ecx, 2
  add	N3/ecx, N3/ecx, 1
  push	N3/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [75->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})

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

+++ ending code for new_gf_xep_6 +++

+++ No Source Code Locators for new_gf_xep_6 +++


+++ Exported function definition new_gf_xep +++

+++ starting code for new_gf_xep +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 55}, {basic-block #({tag 1:65}) 65 95})
  ld	N0/edi, ebx, 8
  ld	N0/edi, N0/edi, 4
  asr	N0/edi, N0/edi, 2
  and	N0/edi, N0/edi, 255
  bne	{tag 1:65}, ecx, N0/edi

#() [30->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  move	G2/edi, ebx
  ld	G1/ebx, G2/edi, 24
  ld	N3/edx, G1/ebx, 12
  move	edi, G2/edi
  move	ebx, G1/ebx

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N3/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:65}) [65->95] (level:0) is #f with stack state #f
#({basic-block #() 95 95})
  preserve-registers-entry	
  asl	N4/ecx, ecx, 2
  add	N4/ecx, N4/ecx, 1
  push	N4/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [95->95] (level:0) is #f with stack state #f
#({basic-block #() 95 100})

#() [95->100] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_xep +++

+++ No Source Code Locators for new_gf_xep +++


+++ Exported function definition new_gf_optional_xep_0 +++

+++ starting code for new_gf_optional_xep_0 +++

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

#() [5->15] (level:0) is #f with stack state #f
#({basic-block #({tag 6:25}) 25 110}, {basic-block #({tag 5:15}) 15 25})
  pop	esi
  bgt	{tag 5:15}, ecx, 0

#({tag 6:25}) [25->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  move	N1/edi, esp
  sub	esp, esp, 12
  push	esi
  asl	ecx, ecx, 2
  move	N0/edx, ecx
  add	ecx, ecx, 1
  st	ecx, N1/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8
  add	N0/edx, N0/edx, 12
  st	N0/edx, N1/edi, -12
  add	N2/eax, N1/edi, -8
  move	eax, N2/eax
  move	G4/edi, ebx
  ld	G3/ebx, G4/edi, 24
  ld	N5/edx, G3/ebx, 12
  move	edi, G4/edi
  move	ebx, G3/ebx

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp	N5/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 5:15}) [15->25] (level:0) is #f with stack state #f
#({basic-block #({tag 6:25}) 25 110})
  st	eax, esp, -4
  sub	esp, esp, 4

#() [155->160] (level:0) is #f with stack state #f
#()
  bra	{tag 6:25}

+++ ending code for new_gf_optional_xep_0 +++

+++ No Source Code Locators for new_gf_optional_xep_0 +++


+++ Exported function definition new_gf_optional_xep_1 +++

+++ starting code for new_gf_optional_xep_1 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 110}, {basic-block #({tag 1:120}) 120 150})
  blo	{tag 1:120}, ecx, 1

#() [10->110] (level:0) is #f with stack state #f
#({basic-block #() 110 115})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  st	esi, esp, 0
  add	N0/edx, N2/edx, 4
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -3
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [110->115] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:120}) [120->150] (level:0) is #f with stack state #f
#({basic-block #() 150 150})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [150->150] (level:0) is #f with stack state #f
#({basic-block #() 150 155})

#() [150->155] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_1 +++

+++ No Source Code Locators for new_gf_optional_xep_1 +++


+++ Exported function definition new_gf_optional_xep_2 +++

+++ starting code for new_gf_optional_xep_2 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 120}, {basic-block #({tag 1:130}) 130 160})
  blo	{tag 1:130}, ecx, 2

#() [10->120] (level:0) is #f with stack state #f
#({basic-block #() 120 125})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  add	N0/edx, N2/edx, 8
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -7
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [120->125] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:130}) [130->160] (level:0) is #f with stack state #f
#({basic-block #() 160 160})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [160->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})

#() [160->165] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_2 +++

+++ No Source Code Locators for new_gf_optional_xep_2 +++


+++ Exported function definition new_gf_optional_xep_3 +++

+++ starting code for new_gf_optional_xep_3 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 130}, {basic-block #({tag 1:140}) 140 170})
  blo	{tag 1:140}, ecx, 3

#() [10->130] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edx, 8
  st	esi, esp, 8
  add	N0/edx, N2/edx, 12
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -11
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [130->135] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:140}) [140->170] (level:0) is #f with stack state #f
#({basic-block #() 170 170})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [170->170] (level:0) is #f with stack state #f
#({basic-block #() 170 175})

#() [170->175] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_3 +++

+++ No Source Code Locators for new_gf_optional_xep_3 +++


+++ Exported function definition new_gf_optional_xep_4 +++

+++ starting code for new_gf_optional_xep_4 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 140}, {basic-block #({tag 1:150}) 150 180})
  blo	{tag 1:150}, ecx, 4

#() [10->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  sub	esp, esp, 16
  add	N2/edx, esp, 16
  move	N1/edi, ecx
  ld	esi, N2/edx, 0
  ld	ecx, N2/edx, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edx, 8
  ld	ecx, N2/edx, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  add	N0/edx, N2/edx, 16
  asl	N1/edi, N1/edi, 2
  move	ecx, N1/edi
  add	N1/edi, N1/edi, -15
  st	N1/edi, N0/edx, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8
  add	ecx, ecx, 12
  st	ecx, N0/edx, -12
  add	N3/edi, N0/edx, -8
  st	N3/edi, N0/edx, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:150}) [150->180] (level:0) is #f with stack state #f
#({basic-block #() 180 180})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [180->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})

#() [180->185] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_4 +++

+++ No Source Code Locators for new_gf_optional_xep_4 +++


+++ Exported function definition new_gf_optional_xep_5 +++

+++ starting code for new_gf_optional_xep_5 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 150}, {basic-block #({tag 1:160}) 160 190})
  blo	{tag 1:160}, ecx, 5

#() [10->150] (level:0) is #f with stack state #f
#({basic-block #() 150 155})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  st	esi, esp, 16
  add	N0/edi, N2/edi, 20
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -19
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [150->155] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:160}) [160->190] (level:0) is #f with stack state #f
#({basic-block #() 190 190})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [190->190] (level:0) is #f with stack state #f
#({basic-block #() 190 195})

#() [190->195] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_5 +++

+++ No Source Code Locators for new_gf_optional_xep_5 +++


+++ Exported function definition new_gf_optional_xep_6 +++

+++ starting code for new_gf_optional_xep_6 +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 160}, {basic-block #({tag 1:170}) 170 200})
  blo	{tag 1:170}, ecx, 6

#() [10->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	esp, esp, 16
  add	N2/edi, esp, 16
  move	N1/edx, ecx
  ld	esi, N2/edi, 0
  ld	ecx, N2/edi, 4
  st	esi, esp, 0
  st	ecx, esp, 4
  ld	esi, N2/edi, 8
  ld	ecx, N2/edi, 12
  st	esi, esp, 8
  st	ecx, esp, 12
  ld	esi, N2/edi, 16
  ld	ecx, N2/edi, 20
  st	esi, esp, 16
  st	ecx, esp, 20
  add	N0/edi, N2/edi, 24
  asl	N1/edx, N1/edx, 2
  move	ecx, N1/edx
  add	N1/edx, N1/edx, -23
  st	N1/edx, N0/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8
  add	ecx, ecx, 12
  st	ecx, N0/edi, -12
  add	N3/edx, N0/edi, -8
  st	N3/edx, N0/edi, -16
  move	G5/edi, ebx
  ld	G4/ebx, G5/edi, 24
  ld	N6/edx, G4/ebx, 12
  move	edi, G5/edi
  move	ebx, G4/ebx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp	N6/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:170}) [170->200] (level:0) is #f with stack state #f
#({basic-block #() 200 200})
  preserve-registers-entry	
  asl	N7/ecx, ecx, 2
  add	N7/ecx, N7/ecx, 1
  push	N7/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [200->200] (level:0) is #f with stack state #f
#({basic-block #() 200 205})

#() [200->205] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep_6 +++

+++ No Source Code Locators for new_gf_optional_xep_6 +++


+++ Exported function definition new_gf_optional_xep +++

+++ starting code for new_gf_optional_xep +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 185}, {basic-block #({tag 1:195}) 195 225})
  ld	N0/edi, ebx, 8
  ld	N0/edi, N0/edi, 4
  asr	N0/edi, N0/edi, 2
  and	N0/edi, N0/edi, 255
  blo	{tag 1:195}, ecx, N0/edi

#() [30->185] (level:0) is #f with stack state #f
#({basic-block #() 185 190})
  ld	N3/edi, ebx, 8
  ld	N3/edi, N3/edi, 4
  asr	N3/edi, N3/edi, 2
  and	N3/edi, N3/edi, 255
  move	esi, esp
  sub	esp, esp, 16
  move	N2/edx, ecx
  move	ecx, N3/edi
  move	N4/edi, esp
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N1/edi, esi
  asl	N2/edx, N2/edx, 2
  move	ecx, N2/edx
  ld	esi, ebx, 8
  ld	esi, esi, 4
  and	esi, esi, 1020
  sub	N2/edx, N2/edx, esi
  add	N2/edx, N2/edx, 1
  st	N2/edx, N1/edi, -4
  st	{constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8
  add	ecx, ecx, 12
  st	ecx, N1/edi, -12
  add	N5/edx, N1/edi, -8
  st	N5/edx, N1/edi, -16
  move	G7/edi, ebx
  ld	G6/ebx, G7/edi, 24
  ld	N8/edx, G6/ebx, 12
  move	edi, G7/edi
  move	ebx, G6/ebx

#() [185->190] (level:0) is #f with stack state #f
#()
  jmp	N8/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:195}) [195->225] (level:0) is #f with stack state #f
#({basic-block #() 225 225})
  preserve-registers-entry	
  asl	N9/ecx, ecx, 2
  add	N9/ecx, N9/ecx, 1
  push	N9/ecx
  move	eax, ebx
  call	{constant "Kargument_count_errorVKiI"}, 1

#() [225->225] (level:0) is #f with stack state #f
#({basic-block #() 225 230})

#() [225->230] (level:0) is #f with stack state #f
#()
  rts	

+++ ending code for new_gf_optional_xep +++

+++ No Source Code Locators for new_gf_optional_xep +++


+++ Exported function definition apply_xep_0 +++

+++ starting code for apply_xep_0 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 85}, {basic-block #({tag 1:90}) 90 100})
  move	N0/eax, eax
  ld	N1/edx, N0/eax, 4
  asr	N1/edx, N1/edx, 2
  ble	{tag 1:90}, N1/edx, 1

#() [25->85] (level:0) is #f with stack state #f
#({basic-block #() 85 90})
  sub	N1/edx, N1/edx, 1
  asl	N2/edi, N1/edx, 2
  ld	esi, esp, 0
  sub	esp, esp, N2/edi
  st	esi, esp, 0
  add	N3/edi, esp, 4
  add	esi, N0/eax, 12
  move	edi, N3/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N1/edx
  add	ecx, N1/edx, 1
  ld	eax, N0/eax, 8

#() [85->90] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:90}) [90->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  move	ecx, N1/edx
  ld	eax, N0/eax, 8

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_0 +++

+++ No Source Code Locators for apply_xep_0 +++


+++ Exported function definition apply_xep_1 +++

+++ starting code for apply_xep_1 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 4
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 1
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 1
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 4
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 1
  ld	esi, esp, 0
  st	esi, esp, 4
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 4
  move	ecx, 2

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_1 +++

+++ No Source Code Locators for apply_xep_1 +++


+++ Exported function definition apply_xep_2 +++

+++ starting code for apply_xep_2 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 8
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 2
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 2
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 8
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 2
  ld	esi, esp, 0
  st	esi, esp, 8
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 8
  move	ecx, 3

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_2 +++

+++ No Source Code Locators for apply_xep_2 +++


+++ Exported function definition apply_xep_3 +++

+++ starting code for apply_xep_3 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 12
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 3
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 3
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 12
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 3
  ld	esi, esp, 0
  st	esi, esp, 12
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 12
  move	ecx, 4

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_3 +++

+++ No Source Code Locators for apply_xep_3 +++


+++ Exported function definition apply_xep_4 +++

+++ starting code for apply_xep_4 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 16
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 4
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 4
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 16
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 4
  ld	esi, esp, 0
  st	esi, esp, 16
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 16
  move	ecx, 5

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_4 +++

+++ No Source Code Locators for apply_xep_4 +++


+++ Exported function definition apply_xep_5 +++

+++ starting code for apply_xep_5 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 20
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 5
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 5
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 20
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 5
  ld	esi, esp, 0
  st	esi, esp, 20
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 20
  move	ecx, 6

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_5 +++

+++ No Source Code Locators for apply_xep_5 +++


+++ Exported function definition apply_xep_6 +++

+++ starting code for apply_xep_6 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 24
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 6
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 6
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 24
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 6
  ld	esi, esp, 0
  st	esi, esp, 24
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 24
  move	ecx, 7

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_6 +++

+++ No Source Code Locators for apply_xep_6 +++


+++ Exported function definition apply_xep_7 +++

+++ starting code for apply_xep_7 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 28
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 7
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 7
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 28
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 7
  ld	esi, esp, 0
  st	esi, esp, 28
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 28
  move	ecx, 8

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_7 +++

+++ No Source Code Locators for apply_xep_7 +++


+++ Exported function definition apply_xep_8 +++

+++ starting code for apply_xep_8 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 32
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 8
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 8
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 32
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 8
  ld	esi, esp, 0
  st	esi, esp, 32
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 32
  move	ecx, 9

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_8 +++

+++ No Source Code Locators for apply_xep_8 +++


+++ Exported function definition apply_xep_9 +++

+++ starting code for apply_xep_9 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:185}) 185 210})
  ld	esi, esp, 36
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 1:185}, N0/edi, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180})
  beq	{tag 2:165}, N0/edi, 1

#() [30->160] (level:0) is #f with stack state #f
#({basic-block #() 160 165})
  sub	N0/edi, N0/edi, 1
  move	ecx, 9
  move	N8/edi, N0/edi
  asl	N8/edi, N8/edi, 2
  move	esi, esp
  sub	esp, esp, N8/edi
  move	ecx, ecx
  move	N7/edi, esp
  move	edi, N7/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N3/edi, esi
  ld	esi, N3/edi, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  add	N5/edi, ecx, 9
  push	N5/edi
  move	N9/ecx, ecx
  add	N4/edi, esp, 36
  add	N4/edi, N4/edi, 4
  pop	N6/edx
  move	edi, N4/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  move	ecx, N6/edx

#() [160->165] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 1:185}) [185->210] (level:0) is #f with stack state #f
#({basic-block #() 210 210})
  move	ecx, 9
  ld	esi, esp, 0
  st	esi, esp, 36
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [210->210] (level:0) is #f with stack state #f
#({basic-block #() 210 215})

#() [210->215] (level:0) is #f with stack state #f
#()
  rts	

#({tag 2:165}) [165->180] (level:0) is #f with stack state #f
#({basic-block #() 180 185})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, 36
  move	ecx, 10

#() [180->185] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep_9 +++

+++ No Source Code Locators for apply_xep_9 +++


+++ Exported function definition apply_xep +++

+++ starting code for apply_xep +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #() 10 10}, {basic-block #({tag 1:15}) 15 45})
  bne	{tag 1:15}, ecx, 1

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

#() [10->15] (level:0) is #f with stack state #f
#()
  jmp	{constant "apply_xep_0"}, 1, 0, #f, #f

#({tag 1:15}) [15->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 2:220}) 220 245})
  sub	N2/edx, ecx, 1
  asl	N3/edx, N2/edx, 2
  ld	esi, esp, N3/edx
  ld	N0/edi, esi, 4
  asr	N0/edi, N0/edi, 2
  beq	{tag 2:220}, N0/edi, 0

#() [45->50] (level:0) is #f with stack state #f
#({basic-block #() 50 195}, {basic-block #({tag 3:200}) 200 215})
  beq	{tag 3:200}, N0/edi, 1

#() [50->195] (level:0) is #f with stack state #f
#({basic-block #() 195 200})
  sub	N0/edi, N0/edi, 1
  asr	N9/ecx, N3/edx, 2
  move	ecx, N9/ecx
  move	N11/edi, N0/edi
  asl	N11/edi, N11/edi, 2
  move	esi, esp
  sub	esp, esp, N11/edi
  move	ecx, ecx
  move	N10/edi, esp
  move	edi, N10/edi
  move	esi, esi
  copy-words-down-w	edi, esi, ecx
  move	N5/ecx, esi
  move	N12/edi, N3/edx
  ld	esi, N5/ecx, 0
  ld	ecx, esi, 4
  asr	ecx, ecx, 2
  add	esi, esi, 8
  asr	N13/edx, N12/edi, 2
  add	N7/edx, ecx, N13/edx
  push	N7/edx
  move	N14/ecx, ecx
  add	N6/edi, esp, N12/edi
  add	N6/edi, N6/edi, 4
  pop	N8/edx
  move	edi, N6/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N14/ecx
  move	ecx, N8/edx

#() [195->200] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

#({tag 2:220}) [220->245] (level:0) is #f with stack state #f
#({basic-block #() 245 245})
  sub	ecx, ecx, 1
  ld	esi, esp, 0
  st	esi, esp, N3/edx
  add	esp, esp, 4
  call-indirect	ebx, 4, 1

#() [245->245] (level:0) is #f with stack state #f
#({basic-block #() 245 250})

#() [245->250] (level:0) is #f with stack state #f
#()
  rts	

#({tag 3:200}) [200->215] (level:0) is #f with stack state #f
#({basic-block #() 215 220})
  ld	N1/edi, esi, 8
  st	N1/edi, esp, N3/edx
  move	ecx, ecx

#() [215->220] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 4, 1, 0, #f, #f

+++ ending code for apply_xep +++

+++ No Source Code Locators for apply_xep +++


+++ Exported function definition primitive_engine_node_apply_with_optionals +++

+++ starting code for primitive_engine_node_apply_with_optionals +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #({tag 3:45}) 45 65})
  move	ebx, eax
  load-stack-arg-n	#t, G2/edx, 0
  load-stack-arg-n	#t, N0/eax, 1
  move	N1/eax, N0/eax
  ld	ecx, N1/eax, 4
  asr	ecx, ecx, 2
  add	eax, N1/eax, 8
  push	G2/edx

#({tag 3:45}) [45->65] (level:1) is #f with stack state #f
#({basic-block #() 65 70}, {basic-block #({tag 2:70}) 70 95})
  ld	N3/edi, G2/edx, 0
  ld	N3/edi, N3/edi, 8
  and	N3/edi, N3/edi, 8192
  beq	{tag 2:70}, N3/edi, 0

#() [65->70] (level:1) is #f with stack state #f
#({basic-block #({tag 3:45}) 45 65})
  ld	G2/edx, G2/edx, 20

#() [430->435] (level:0) is #f with stack state #f
#()
  bra	{tag 3:45}

#({tag 2:70}) [70->95] (level:1) is #f with stack state #f
#({basic-block #() 95 100}, {basic-block #({tag 1:285}) 285 290})
  ld	N3/edi, G2/edx, 8
  ld	N3/edi, N3/edi, 4
  pop	G2/edx
  and	N3/edi, N3/edi, 1310720
  bne	{tag 1:285}, N3/edi, 0

#() [95->100] (level:1) is #f with stack state #f
#({basic-block #() 100 105}, {basic-block #({tag 5:115}) 115 125})
  beq	{tag 5:115}, ecx, 0

#() [100->105] (level:1) is #f with stack state #f
#({basic-block #() 105 110}, {basic-block #({tag 6:130}) 130 145})
  beq	{tag 6:130}, ecx, 1

#() [105->110] (level:1) is #f with stack state #f
#({basic-block #() 110 115}, {basic-block #({tag 7:150}) 150 175})
  beq	{tag 7:150}, ecx, 2

#() [110->115] (level:1) is #f with stack state #f
#({basic-block #({tag 4:215}) 215 280}, {basic-block #({tag 8:180}) 180 210})
  beq	{tag 8:180}, ecx, 3

#({tag 4:215}) [215->280] (level:1) is #f with stack state #f
#({basic-block #() 280 285})
  sub	ecx, ecx, 1
  pop	esi
  add	esp, esp, 8
  asl	N5/edi, ecx, 2
  sub	esp, esp, N5/edi
  move	N4/edi, esp
  push	esi
  add	eax, eax, 4
  move	edi, N4/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  move	edi, G2/edx
  ld	eax, eax, -4

#() [280->285] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 1:285}) [285->290] (level:1) is #f with stack state #f
#({basic-block #() 290 295}, {basic-block #({tag 10:295}) 295 315})
  beq	{tag 10:295}, ecx, 1

#() [290->295] (level:1) is #f with stack state #f
#({basic-block #({tag 9:350}) 350 425}, {basic-block #({tag 11:320}) 320 345})
  beq	{tag 11:320}, ecx, 2

#({tag 9:350}) [350->425] (level:1) is #f with stack state #f
#({basic-block #() 425 430})
  asl	N7/edi, ecx, 2
  store-stack-arg-n	N7/edi, 1
  pop	esi
  sub	ecx, ecx, 1
  add	esp, esp, 4
  asl	N8/edi, ecx, 2
  sub	esp, esp, N8/edi
  move	N6/edi, esp
  push	esi
  add	eax, eax, 4
  move	edi, N6/edi
  move	esi, eax
  copy-words-down-w	edi, esi, ecx
  move	edi, G2/edx
  ld	eax, eax, -4

#() [425->430] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:115}) [115->125] (level:1) is #f with stack state #f
#({basic-block #() 125 130})
  move-return-address	#f, 8, #f
  move	edi, G2/edx

#() [125->130] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 6:130}) [130->145] (level:1) is #f with stack state #f
#({basic-block #() 145 150})
  move-return-address	#f, 8, #f
  move	edi, G2/edx
  ld	eax, eax, 0

#() [145->150] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 7:150}) [150->175] (level:1) is #f with stack state #f
#({basic-block #() 175 180})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 1
  move-return-address	#f, 4, #f
  move	edi, G2/edx
  ld	eax, eax, 0

#() [175->180] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 8:180}) [180->210] (level:1) is #f with stack state #f
#({basic-block #() 210 215})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 0
  ld	esi, eax, 8
  store-stack-arg-n	esi, 1
  move	edi, G2/edx
  ld	eax, eax, 0

#() [210->215] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 10:295}) [295->315] (level:1) is #f with stack state #f
#({basic-block #() 315 320})
  store-stack-arg-n	4, 1
  move-return-address	#f, 4, #f
  move	edi, G2/edx
  ld	eax, eax, 0

#() [315->320] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 11:320}) [320->345] (level:1) is #f with stack state #f
#({basic-block #() 345 350})
  ld	esi, eax, 4
  store-stack-arg-n	esi, 0
  store-stack-arg-n	8, 1
  move	edi, G2/edx
  ld	eax, eax, 0

#() [345->350] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for primitive_engine_node_apply_with_optionals +++

+++ No Source Code Locators for primitive_engine_node_apply_with_optionals +++


+++ Exported function definition general_engine_node_1_entry +++

+++ starting code for general_engine_node_1_entry +++

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

#() [5->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  sub	esp, esp, 8
  ld	esi, esp, 8
  st	esi, esp, 0
  st	ebx, esp, 4
  st	edi, esp, 8
  ld	N0/ebx, ebx, 8

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N0/ebx, 1, 0, #f, #f

+++ ending code for general_engine_node_1_entry +++

+++ No Source Code Locators for general_engine_node_1_entry +++


+++ Exported function definition general_engine_node_2_entry +++

+++ starting code for general_engine_node_2_entry +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50})
  sub	esp, esp, 8
  ld	esi, esp, 8
  st	esi, esp, 0
  ld	esi, esp, 12
  st	esi, esp, 4
  st	ebx, esp, 8
  st	edi, esp, 12
  ld	N0/ebx, ebx, 8

#() [45->50] (level:0) is #f with stack state #f
#()
  jmp	N0/ebx, 1, 0, #f, #f

+++ ending code for general_engine_node_2_entry +++

+++ No Source Code Locators for general_engine_node_2_entry +++


+++ Exported function definition general_engine_node_3_entry +++

+++ starting code for general_engine_node_3_entry +++

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

#() [5->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  sub	esp, esp, 8
  ld	esi, esp, 8
  st	esi, esp, 0
  ld	esi, esp, 12
  st	esi, esp, 4
  ld	esi, esp, 16
  st	esi, esp, 8
  st	ebx, esp, 12
  st	edi, esp, 16
  ld	N0/ebx, ebx, 8

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N0/ebx, 1, 0, #f, #f

+++ ending code for general_engine_node_3_entry +++

+++ No Source Code Locators for general_engine_node_3_entry +++


+++ Exported function definition general_engine_node_n_0 +++

+++ starting code for general_engine_node_n_0 +++

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

#() [5->20] (level:0) is #f with stack state #f
#({basic-block #({tag 2:20}) 20 40})
  move	G2/ebx, ebx
  move	G1/edx, edi
  move	G0/eax, G1/edx

#({tag 2:20}) [20->40] (level:1) is #f with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 100})
  ld	N3/edi, G0/eax, 0
  ld	N3/edi, N3/edi, 8
  and	N3/edi, N3/edi, 8192
  beq	{tag 1:45}, N3/edi, 0

#() [40->45] (level:1) is #f with stack state #f
#({basic-block #({tag 2:20}) 20 40})
  ld	G0/eax, G0/eax, 20

#() [110->115] (level:0) is #f with stack state #f
#()
  bra	{tag 2:20}

#({tag 1:45}) [45->100] (level:1) is #f with stack state #f
#({basic-block #() 100 105})
  pop	N4/edi
  push	1
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G0/eax, esp
  push	N4/edi
  preserve-registers-entry	
  ld	N6/edi, G2/ebx, 8
  push	G1/edx
  push	G2/ebx
  move	eax, G0/eax
  call	N6/edi, 1

#() [100->105] (level:1) is #f with stack state #f
#({basic-block #() 105 110})
  preserve-registers-exit	

#() [105->110] (level:1) is #f with stack state #f
#()
  rts-and-drop	8

+++ ending code for general_engine_node_n_0 +++

+++ Live variable scopes for general_engine_node_n_0 +++
Start scope at 39 with frame for no variables
End scope at 45

+++ No Source Code Locators for general_engine_node_n_0 +++


+++ Exported function definition general_engine_node_n +++

+++ starting code for general_engine_node_n +++

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

#() [5->20] (level:0) is #f with stack state #f
#({basic-block #({tag 2:20}) 20 40})
  move	G2/ebx, ebx
  move	G1/ecx, edi
  move	G0/edi, G1/ecx

#({tag 2:20}) [20->40] (level:1) is #f with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 125})
  ld	N3/edx, G0/edi, 0
  ld	N3/edx, N3/edx, 8
  and	N3/edx, N3/edx, 8192
  beq	{tag 1:45}, N3/edx, 0

#() [40->45] (level:1) is #f with stack state #f
#({basic-block #({tag 2:20}) 20 40})
  ld	G0/edi, G0/edi, 20

#() [145->150] (level:0) is #f with stack state #f
#()
  bra	{tag 2:20}

#({tag 1:45}) [45->125] (level:1) is #f with stack state #f
#({basic-block #() 125 140})
  ld	N4/edi, G0/edi, 8
  ld	N4/edi, N4/edi, 4
  and	N4/edi, N4/edi, 1020
  pop	N5/edx
  push	eax
  add	G7/edi, N4/edi, 1
  push	G7/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G0/edi, esp
  push	N5/edx
  preserve-registers-entry	
  ld	N8/edx, G2/ebx, 8
  push	G1/ecx
  push	G2/ebx
  move	eax, G0/edi
  call	N8/edx, 1

#() [125->140] (level:1) is #f with stack state #f
#({basic-block #() 140 145})
  preserve-registers-exit	
  ld	G9/edi, esp, 8
  add	N10/edi, G9/edi, 7

#() [140->145] (level:1) is #f with stack state #f
#()
  rts-and-drop	N10/edi

+++ ending code for general_engine_node_n +++

+++ Live variable scopes for general_engine_node_n +++
Start scope at 54 with frame for no variables
End scope at 62

+++ No Source Code Locators for general_engine_node_n +++


+++ Exported function definition general_engine_node_n_optionals_0 +++

+++ starting code for general_engine_node_n_optionals_0 +++

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

#() [5->85] (level:0) is #f with stack state #f
#({basic-block #() 85 95})
  move	G1/ebx, ebx
  move	G0/edi, edi
  preserve-registers-entry	
  push	G0/edi
  sub	esp, esp, 4
  push	5
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G3/eax, eax
  st-index	G3/eax, esp, 0, 8
  move	G2/eax, esp
  ld	G0/edi, ebp, -4
  ld	N4/edx, G1/ebx, 8
  push	G0/edi
  push	G1/ebx
  move	eax, G2/eax
  call	N4/edx, 1

#() [85->95] (level:0) is #f with stack state #f
#({basic-block #() 95 100})
  preserve-registers-exit	
  load-stack-arg-n	#t, N5/edi, 0

#() [95->100] (level:0) is #f with stack state #f
#()
  rts-and-drop	N5/edi

+++ ending code for general_engine_node_n_optionals_0 +++

+++ Live variable scopes for general_engine_node_n_optionals_0 +++
Start scope at 3 with frame for no variables
End scope at 29

+++ No Source Code Locators for general_engine_node_n_optionals_0 +++


+++ Exported function definition general_engine_node_n_optionals +++

+++ starting code for general_engine_node_n_optionals +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #({tag 2:30}) 30 50})
  move	G1/ebx, ebx
  move	G0/edi, edi
  preserve-registers-entry	
  push	G0/edi
  move	G0/edi, G0/edi

#({tag 2:30}) [30->50] (level:1) is #f with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 225})
  ld	N4/edx, G0/edi, 0
  ld	N4/edx, N4/edx, 8
  and	N4/edx, N4/edx, 8192
  beq	{tag 1:55}, N4/edx, 0

#() [50->55] (level:1) is #f with stack state #f
#({basic-block #({tag 2:30}) 30 50})
  ld	G0/edi, G0/edi, 20

#() [250->255] (level:0) is #f with stack state #f
#()
  bra	{tag 2:30}

#({tag 1:55}) [55->225] (level:1) is #f with stack state #f
#({basic-block #() 225 245})
  ld	N3/edx, G0/edi, 8
  ld	N3/edx, N3/edx, 4
  and	N3/edx, N3/edx, 1020
  pop	G0/edi
  preserve-registers-exit	
  preserve-registers-entry	
  push	G0/edi
  push	G1/ebx
  add	N5/edi, N3/edx, 4
  sub	esp, esp, N5/edi
  add	G6/edi, N5/edi, 1
  push	G6/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G7/eax, eax
  st	G7/eax, esp, 8
  add	esi, ebp, 8
  add	N8/edi, esp, 12
  asr	N9/ecx, N3/edx, 2
  sub	N9/ecx, N9/ecx, 1
  move	edi, N8/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N9/ecx
  add	N11/edi, N3/edx, 4
  ld	G10/edi, ebp, N11/edi
  st-index	G10/edi, esp, N3/edx, 8
  move	G2/eax, esp
  push	N3/edx
  ld	G1/ebx, ebp, -8
  ld	G0/edi, ebp, -4
  ld	N12/edx, G1/ebx, 8
  push	G0/edi
  push	G1/ebx
  move	eax, G2/eax
  call	N12/edx, 1

#() [225->245] (level:1) is #f with stack state #f
#({basic-block #() 245 250})
  pop	N3/edx
  preserve-registers-exit	
  add	N14/edx, N3/edx, 4
  ld	N13/edx, esp, N14/edx

#() [245->250] (level:1) is #f with stack state #f
#()
  rts-and-drop	N13/edx

+++ ending code for general_engine_node_n_optionals +++

+++ Live variable scopes for general_engine_node_n_optionals +++
Start scope at 3 with frame for no variables
End scope at 37
Start scope at 38 no frame for no variables
End scope at 41
Start scope at 42 with frame for no variables
End scope at 106

+++ No Source Code Locators for general_engine_node_n_optionals +++


+++ Exported function definition general_engine_node_spread_optionals_0 +++

+++ starting code for general_engine_node_spread_optionals_0 +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 70})
  move	G1/ebx, ebx
  move	G0/edi, edi
  preserve-registers-entry	
  push	G0/edi
  move	G2/eax, eax
  ld	G0/edi, ebp, -4
  ld	N3/edx, G1/ebx, 8
  push	G0/edi
  push	G1/ebx
  move	eax, G2/eax
  call	N3/edx, 1

#() [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  preserve-registers-exit	
  load-stack-arg-n	#t, N4/edi, 0

#() [70->75] (level:0) is #f with stack state #f
#()
  rts-and-drop	N4/edi

+++ ending code for general_engine_node_spread_optionals_0 +++

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

+++ No Source Code Locators for general_engine_node_spread_optionals_0 +++


+++ Exported function definition general_engine_node_spread_optionals +++

+++ starting code for general_engine_node_spread_optionals +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #({tag 2:30}) 30 50})
  move	G1/ebx, ebx
  move	G0/edi, edi
  preserve-registers-entry	
  push	G0/edi
  move	G0/edi, G0/edi

#({tag 2:30}) [30->50] (level:1) is #f with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 285})
  ld	N4/edx, G0/edi, 0
  ld	N4/edx, N4/edx, 8
  and	N4/edx, N4/edx, 8192
  beq	{tag 1:55}, N4/edx, 0

#() [50->55] (level:1) is #f with stack state #f
#({basic-block #({tag 2:30}) 30 50})
  ld	G0/edi, G0/edi, 20

#() [310->315] (level:0) is #f with stack state #f
#()
  bra	{tag 2:30}

#({tag 1:55}) [55->285] (level:1) is #f with stack state #f
#({basic-block #() 285 305})
  ld	N3/edx, G0/edi, 8
  ld	N3/edx, N3/edx, 4
  and	N3/edx, N3/edx, 1020
  pop	G0/edi
  preserve-registers-exit	
  preserve-registers-entry	
  push	G0/edi
  push	G1/ebx
  add	N8/edi, N3/edx, 4
  ld	G5/edi, ebp, N8/edi
  ld	N6/edi, G5/edi, 4
  sub	N6/edi, N6/edi, 1
  sub	esp, esp, N6/edi
  add	N7/edi, N6/edi, N3/edx
  sub	esp, esp, N3/edx
  add	G9/edi, N7/edi, 1
  push	G9/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G10/eax, eax
  st	G10/eax, esp, 8
  add	esi, ebp, 8
  add	N11/edi, esp, 12
  asr	N12/ecx, N3/edx, 2
  sub	N12/ecx, N12/ecx, 1
  move	edi, N11/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N12/ecx
  add	N17/edi, N3/edx, 4
  ld	G13/edi, ebp, N17/edi
  ld	N15/ecx, G13/edi, 4
  asr	N15/ecx, N15/ecx, 2
  add	N16/ebx, G13/edi, 8
  add	N14/edi, esp, 8
  add	N14/edi, N14/edi, N3/edx
  move	edi, N14/edi
  move	esi, N16/ebx
  copy-words-down-w	edi, esi, N15/ecx
  move	G2/eax, esp
  push	N3/edx
  ld	G1/ebx, ebp, -8
  ld	G0/edi, ebp, -4
  ld	N18/edx, G1/ebx, 8
  push	G0/edi
  push	G1/ebx
  move	eax, G2/eax
  call	N18/edx, 1

#() [285->305] (level:1) is #f with stack state #f
#({basic-block #() 305 310})
  pop	N3/edx
  preserve-registers-exit	
  add	N20/edx, N3/edx, 4
  ld	N19/edx, esp, N20/edx

#() [305->310] (level:1) is #f with stack state #f
#()
  rts-and-drop	N19/edx

+++ ending code for general_engine_node_spread_optionals +++

+++ Live variable scopes for general_engine_node_spread_optionals +++
Start scope at 3 with frame for no variables
End scope at 37
Start scope at 38 no frame for no variables
End scope at 41
Start scope at 42 with frame for no variables
End scope at 135

+++ No Source Code Locators for general_engine_node_spread_optionals +++


+++ Exported function definition boxed_instance_slot_getter_entry +++

+++ starting code for boxed_instance_slot_getter_entry +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 1:45}) 45 80})
  move	G2/eax, eax
  ld	N3/ebx, ebx, 8
  add	N3/ebx, N3/ebx, 3
  ld	G0/edi, G2/eax, N3/ebx
  beq	{tag 1:45}, G0/edi, {constant "KPunboundVKi"}

#() [30->35] (level:0) is #f with stack state #f
#({basic-block #({tag 2:35}) 35 40})
  move	eax, G0/edi

#({tag 2:35}) [35->40] (level:0) is #f with stack state #f
#({basic-block #() 40 45})
  reset-values	

#() [40->45] (level:0) is #f with stack state #f
#()
  rts-and-drop	0

#({tag 1:45}) [45->80] (level:0) is #f with stack state #f
#({basic-block #({tag 2:35}) 35 40})
  asr	N4/ebx, N3/ebx, 2
  sub	N4/ebx, N4/ebx, 1
  asl	G1/ebx, N4/ebx, 2
  add	G1/ebx, G1/ebx, 1
  push	G1/ebx
  move	eax, G2/eax
  call	{constant "Kunbound_instance_slotVKeI"}, 1

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 2:35}

+++ ending code for boxed_instance_slot_getter_entry +++

+++ No Source Code Locators for boxed_instance_slot_getter_entry +++


+++ Exported function definition boxed_instance_slot_setter_entry +++

+++ starting code for boxed_instance_slot_setter_entry +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 45})
  move	G0/eax, eax
  load-stack-arg-n	#t, G1/edi, 0
  ld	N2/ebx, ebx, 8
  add	N2/ebx, N2/ebx, 3
  st	G0/eax, G1/edi, N2/ebx
  move	eax, G0/eax
  reset-values	

#() [40->45] (level:0) is #f with stack state #f
#()
  rts-and-drop	4

+++ ending code for boxed_instance_slot_setter_entry +++

+++ No Source Code Locators for boxed_instance_slot_setter_entry +++


+++ Exported function definition boxed_repeated_instance_slot_getter_entry +++

+++ starting code for boxed_repeated_instance_slot_getter_entry +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 1:75}) 75 90})
  move	G2/eax, eax
  load-stack-arg-n	#t, G3/edi, 0
  ld	N4/ebx, ebx, 8
  add	N4/ebx, N4/ebx, 3
  add	N6/ebx, G2/eax, N4/ebx
  ld	G0/edx, N6/ebx, -4
  blt	{tag 1:75}, G3/edi, 0

#() [40->45] (level:0) is #f with stack state #f
#({basic-block #() 45 60}, {basic-block #({tag 1:75}) 75 90})
  bge	{tag 1:75}, G3/edi, G0/edx

#() [45->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 2:90}) 90 105})
  and	N5/edx, G3/edi, -4
  ld	G1/ebx, N6/ebx, N5/edx
  beq	{tag 2:90}, G1/ebx, {constant "KPunboundVKi"}

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #({tag 3:65}) 65 70})
  move	eax, G1/ebx

#({tag 3:65}) [65->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  reset-values	

#() [70->75] (level:0) is #f with stack state #f
#()
  rts-and-drop	4

#({tag 1:75}) [75->90] (level:0) is #f with stack state #f
#({basic-block #({tag 3:65}) 65 70})
  push	G3/edi
  move	eax, G2/eax
  call	{constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 3:65}

#({tag 2:90}) [90->105] (level:0) is #f with stack state #f
#({basic-block #({tag 3:65}) 65 70})
  push	G3/edi
  move	eax, G2/eax
  call	{constant "Kunbound_repeated_slotVKeI"}, 1

#() [110->115] (level:0) is #f with stack state #f
#()
  bra	{tag 3:65}

+++ ending code for boxed_repeated_instance_slot_getter_entry +++

+++ No Source Code Locators for boxed_repeated_instance_slot_getter_entry +++


+++ Exported function definition boxed_repeated_instance_slot_setter_entry +++

+++ starting code for boxed_repeated_instance_slot_setter_entry +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 1:75}) 75 90})
  move	G1/edx, eax
  load-stack-arg-n	#t, G2/eax, 0
  load-stack-arg-n	#t, G3/edi, 1
  ld	N4/ebx, ebx, 8
  add	N4/ebx, N4/ebx, 3
  add	N6/ebx, G2/eax, N4/ebx
  ld	G0/ecx, N6/ebx, -4
  blt	{tag 1:75}, G3/edi, 0

#() [45->50] (level:0) is #f with stack state #f
#({basic-block #() 50 65}, {basic-block #({tag 1:75}) 75 90})
  bge	{tag 1:75}, G3/edi, G0/ecx

#() [50->65] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 70})
  and	N5/edi, G3/edi, -4
  st	G1/edx, N6/ebx, N5/edi
  move	eax, G1/edx

#({tag 2:65}) [65->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  reset-values	

#() [70->75] (level:0) is #f with stack state #f
#()
  rts-and-drop	4

#({tag 1:75}) [75->90] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 70})
  push	G3/edi
  move	eax, G2/eax
  call	{constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1

#() [90->95] (level:0) is #f with stack state #f
#()
  bra	{tag 2:65}

+++ ending code for boxed_repeated_instance_slot_setter_entry +++

+++ No Source Code Locators for boxed_repeated_instance_slot_setter_entry +++


+++ Exported function definition raw_byte_repeated_instance_slot_getter_entry +++

+++ starting code for raw_byte_repeated_instance_slot_getter_entry +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 1:75}) 75 90})
  move	G1/eax, eax
  load-stack-arg-n	#t, G2/edi, 0
  ld	N3/ebx, ebx, 8
  add	N3/ebx, N3/ebx, 3
  add	N6/ebx, G1/eax, N3/ebx
  ld	G0/edx, N6/ebx, -4
  blt	{tag 1:75}, G2/edi, 0

#() [40->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65}, {basic-block #({tag 1:75}) 75 90})
  bge	{tag 1:75}, G2/edi, G0/edx

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 70})
  asr	N5/eax, G2/edi, 2
  ldb	N4/eax, N6/ebx, N5/eax
  asl	eax, N4/eax, 2
  add	eax, eax, 2

#({tag 2:65}) [65->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  reset-values	

#() [70->75] (level:0) is #f with stack state #f
#()
  rts-and-drop	4

#({tag 1:75}) [75->90] (level:0) is #f with stack state #f
#({basic-block #({tag 2:65}) 65 70})
  push	G2/edi
  move	eax, G1/eax
  call	{constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1

#() [90->95] (level:0) is #f with stack state #f
#()
  bra	{tag 2:65}

+++ ending code for raw_byte_repeated_instance_slot_getter_entry +++

+++ No Source Code Locators for raw_byte_repeated_instance_slot_getter_entry +++


+++ Exported function definition raw_byte_repeated_instance_slot_setter_entry +++

+++ starting code for raw_byte_repeated_instance_slot_setter_entry +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 1:80}) 80 95})
  move	G1/edx, eax
  load-stack-arg-n	#t, G2/eax, 0
  load-stack-arg-n	#t, G3/edi, 1
  ld	N4/ebx, ebx, 8
  add	N4/ebx, N4/ebx, 3
  add	N7/ebx, G2/eax, N4/ebx
  ld	G0/ecx, N7/ebx, -4
  blt	{tag 1:80}, G3/edi, 0

#() [45->50] (level:0) is #f with stack state #f
#({basic-block #() 50 70}, {basic-block #({tag 1:80}) 80 95})
  bge	{tag 1:80}, G3/edi, G0/ecx

#() [50->70] (level:0) is #f with stack state #f
#({basic-block #({tag 2:70}) 70 75})
  asr	N5/eax, G1/edx, 2
  asr	N6/edi, G3/edi, 2
  stb	N5/eax, N7/ebx, N6/edi
  move	eax, G1/edx

#({tag 2:70}) [70->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})
  reset-values	

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

#({tag 1:80}) [80->95] (level:0) is #f with stack state #f
#({basic-block #({tag 2:70}) 70 75})
  push	G3/edi
  move	eax, G2/eax
  call	{constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1

#() [95->100] (level:0) is #f with stack state #f
#()
  bra	{tag 2:70}

+++ ending code for raw_byte_repeated_instance_slot_setter_entry +++

+++ No Source Code Locators for raw_byte_repeated_instance_slot_setter_entry +++


+++ Exported function definition single_method_entry +++

+++ starting code for single_method_entry +++

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

#() [5->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  move	G0/ebx, ebx
  rem	"eliminated"
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for single_method_entry +++

+++ No Source Code Locators for single_method_entry +++


+++ Exported function definition unrestricted_keyed_single_method_entry_0 +++

+++ starting code for unrestricted_keyed_single_method_entry_0 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 95}, {basic-block #({tag 1:110}) 110 130})
  move	G0/ebx, ebx
  move	G1/edi, edi
  move	N2/edx, eax
  ld	N3/edx, N2/edx, 4
  nbit	{tag 1:110}, N3/edx, 4, 0

#() [30->95] (level:0) is #f with stack state #f
#({basic-block #() 95 105})
  preserve-registers-entry	
  push	G1/edi
  sub	esp, esp, 4
  push	5
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G5/eax, eax
  st-index	G5/eax, esp, 0, 8
  move	G4/eax, esp
  ld	G1/edi, ebp, -4
  push	G0/ebx
  push	G1/edi
  move	eax, G4/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [95->105] (level:0) is #f with stack state #f
#({basic-block #() 105 110})
  preserve-registers-exit	
  load-stack-arg-n	#t, N6/edi, 0

#() [105->110] (level:0) is #f with stack state #f
#()
  rts-and-drop	N6/edi

#({tag 1:110}) [110->130] (level:0) is #f with stack state #f
#({basic-block #() 130 135})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [130->135] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for unrestricted_keyed_single_method_entry_0 +++

+++ Live variable scopes for unrestricted_keyed_single_method_entry_0 +++
Start scope at 13 with frame for no variables
End scope at 39

+++ No Source Code Locators for unrestricted_keyed_single_method_entry_0 +++


+++ Exported function definition unrestricted_keyed_single_method_entry_1 +++

+++ starting code for unrestricted_keyed_single_method_entry_1 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 105}, {basic-block #({tag 1:120}) 120 140})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, N2/edx, 0
  ld	N3/edx, N2/edx, 4
  nbit	{tag 1:120}, N3/edx, 4, 0

#() [30->105] (level:0) is #f with stack state #f
#({basic-block #() 105 115})
  preserve-registers-entry	
  push	G1/edi
  sub	esp, esp, 8
  push	9
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G5/eax, eax
  st	G5/eax, esp, 8
  ld	G6/edi, ebp, 8
  st-index	G6/edi, esp, 4, 8
  move	G4/eax, esp
  ld	G1/edi, ebp, -4
  push	G0/ebx
  push	G1/edi
  move	eax, G4/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [105->115] (level:0) is #f with stack state #f
#({basic-block #() 115 120})
  preserve-registers-exit	
  load-stack-arg-n	#t, N7/edi, 1

#() [115->120] (level:0) is #f with stack state #f
#()
  rts-and-drop	N7/edi

#({tag 1:120}) [120->140] (level:0) is #f with stack state #f
#({basic-block #() 140 145})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [140->145] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for unrestricted_keyed_single_method_entry_1 +++

+++ Live variable scopes for unrestricted_keyed_single_method_entry_1 +++
Start scope at 15 with frame for no variables
End scope at 48

+++ No Source Code Locators for unrestricted_keyed_single_method_entry_1 +++


+++ Exported function definition unrestricted_keyed_single_method_entry_2 +++

+++ starting code for unrestricted_keyed_single_method_entry_2 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 115}, {basic-block #({tag 1:130}) 130 150})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, N2/edx, 1
  ld	N3/edx, N2/edx, 4
  nbit	{tag 1:130}, N3/edx, 4, 0

#() [30->115] (level:0) is #f with stack state #f
#({basic-block #() 115 125})
  preserve-registers-entry	
  push	G1/edi
  sub	esp, esp, 12
  push	13
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G5/eax, eax
  st	G5/eax, esp, 8
  ld	G6/edi, ebp, 8
  st	G6/edi, esp, 12
  ld	G7/edi, ebp, 12
  st-index	G7/edi, esp, 8, 8
  move	G4/eax, esp
  ld	G1/edi, ebp, -4
  push	G0/ebx
  push	G1/edi
  move	eax, G4/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [115->125] (level:0) is #f with stack state #f
#({basic-block #() 125 130})
  preserve-registers-exit	
  load-stack-arg-n	#t, N8/edi, 2

#() [125->130] (level:0) is #f with stack state #f
#()
  rts-and-drop	N8/edi

#({tag 1:130}) [130->150] (level:0) is #f with stack state #f
#({basic-block #() 150 155})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [150->155] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for unrestricted_keyed_single_method_entry_2 +++

+++ Live variable scopes for unrestricted_keyed_single_method_entry_2 +++
Start scope at 15 with frame for no variables
End scope at 55

+++ No Source Code Locators for unrestricted_keyed_single_method_entry_2 +++


+++ Exported function definition unrestricted_keyed_single_method_entry +++

+++ starting code for unrestricted_keyed_single_method_entry +++

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

#() [5->50] (level:0) is #f with stack state #f
#({basic-block #() 50 205}, {basic-block #({tag 1:230}) 230 250})
  move	G0/ebx, ebx
  move	G1/edi, edi
  ld	N4/edx, G0/ebx, 4
  asr	N4/edx, N4/edx, 6
  and	N4/edx, N4/edx, 1020
  move	N5/edx, N4/edx
  ld	N2/edx, esp, N5/edx
  ld	N3/edx, N2/edx, 4
  nbit	{tag 1:230}, N3/edx, 4, 0

#() [50->205] (level:0) is #f with stack state #f
#({basic-block #() 205 225})
  ld	N7/edx, G0/ebx, 4
  asr	N7/edx, N7/edx, 6
  and	N7/edx, N7/edx, 1020
  preserve-registers-entry	
  push	G1/edi
  push	G0/ebx
  add	N8/edi, N7/edx, 4
  sub	esp, esp, N8/edi
  add	G9/edi, N8/edi, 1
  push	G9/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G10/eax, eax
  st	G10/eax, esp, 8
  add	esi, ebp, 8
  add	N11/edi, esp, 12
  asr	N12/ecx, N7/edx, 2
  sub	N12/ecx, N12/ecx, 1
  move	edi, N11/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N12/ecx
  add	N14/edi, N7/edx, 4
  ld	G13/edi, ebp, N14/edi
  st-index	G13/edi, esp, N7/edx, 8
  move	G6/eax, esp
  push	N7/edx
  ld	G0/ebx, ebp, -8
  ld	G1/edi, ebp, -4
  push	G0/ebx
  push	G1/edi
  move	eax, G6/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [205->225] (level:0) is #f with stack state #f
#({basic-block #() 225 230})
  pop	N7/edx
  preserve-registers-exit	
  add	N16/edx, N7/edx, 4
  ld	N15/edx, esp, N16/edx

#() [225->230] (level:0) is #f with stack state #f
#()
  rts-and-drop	N15/edx

#({tag 1:230}) [230->250] (level:0) is #f with stack state #f
#({basic-block #() 250 255})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [250->255] (level:0) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

+++ ending code for unrestricted_keyed_single_method_entry +++

+++ Live variable scopes for unrestricted_keyed_single_method_entry +++
Start scope at 38 with frame for no variables
End scope at 102

+++ No Source Code Locators for unrestricted_keyed_single_method_entry +++


+++ Exported function definition explicit_keyed_single_method_entry_0 +++

+++ starting code for explicit_keyed_single_method_entry_0 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175})
  move	G0/ebx, ebx
  move	G1/edi, edi
  move	G2/edx, eax
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:170}, G4/edx, 4, 0

#() [30->80] (level:0) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  move	G3/edx, eax
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G5/ebx, G0/ebx, 24
  ld	N6/edi, eax, 4
  sub	N6/edi, N6/edi, 1
  add	N6/edi, N6/edi, eax

#({tag 6:80}) [80->85] (level:1) is #f with stack state #f
#({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170})
  ble	{tag 7:150}, N6/edi, eax

#() [85->105] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  ld	esi, N6/edi, 0
  ld	ebp, G5/ebx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/ebx

#({tag 8:105}) [105->110] (level:2) is #f with stack state #f
#({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150})
  ble	{tag 5:130}, ebp, G5/ebx

#() [110->120] (level:2) is #f with stack state #f
#({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130})
  ld	N7/edx, ebp, 4
  beq	{tag 9:125}, N7/edx, esi

#() [120->125] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  sub	ebp, ebp, 4

#() [335->340] (level:0) is #f with stack state #f
#()
  bra	{tag 8:105}

#({tag 2:170}) [170->175] (level:0) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 235})
  move	esi, 0

#({tag 3:175}) [175->235] (level:2) is #f with stack state #f
#({basic-block #() 235 275}, {basic-block #({tag 11:275}) 275 295})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 4
  push	5
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G9/eax, eax
  st-index	G9/eax, esp, 0, 8
  move	G8/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:275}, esi, 0

#() [235->275] (level:2) is #f with stack state #f
#({basic-block #({tag 10:295}) 295 305})
  ld	G10/edx, G0/ebx, 24
  push	{constant "KPfalseVKi"}
  push	G10/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:295}) [295->305] (level:2) is #f with stack state #f
#({basic-block #() 305 310})
  preserve-registers-exit	
  load-stack-arg-n	#t, N11/edi, 0

#() [305->310] (level:2) is #f with stack state #f
#()
  rts-and-drop	N11/edi

#({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f
#({basic-block #({tag 1:310}) 310 330})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:310}) [310->330] (level:1) is #f with stack state #f
#({basic-block #() 330 335})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [330->335] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:130}) [130->150] (level:2) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 235})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [340->345] (level:0) is #f with stack state #f
#()
  bra	{tag 3:175}

#({tag 9:125}) [125->130] (level:2) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  sub	N6/edi, N6/edi, 8

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

#({tag 11:275}) [275->295] (level:2) is #f with stack state #f
#({basic-block #({tag 10:295}) 295 305})
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [350->355] (level:0) is #f with stack state #f
#()
  bra	{tag 10:295}

+++ ending code for explicit_keyed_single_method_entry_0 +++

+++ Live variable scopes for explicit_keyed_single_method_entry_0 +++
Start scope at 64 with frame for no variables
End scope at 109

+++ No Source Code Locators for explicit_keyed_single_method_entry_0 +++


+++ Exported function definition explicit_keyed_single_method_entry_1 +++

+++ starting code for explicit_keyed_single_method_entry_1 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, G2/edx, 0
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:170}, G4/edx, 4, 0

#() [30->80] (level:0) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  load-stack-arg-n	#t, G3/edx, 0
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G5/ebx, G0/ebx, 24
  ld	N6/edi, eax, 4
  sub	N6/edi, N6/edi, 1
  add	N6/edi, N6/edi, eax

#({tag 6:80}) [80->85] (level:1) is #f with stack state #f
#({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170})
  ble	{tag 7:150}, N6/edi, eax

#() [85->105] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  ld	esi, N6/edi, 0
  ld	ebp, G5/ebx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/ebx

#({tag 8:105}) [105->110] (level:2) is #f with stack state #f
#({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150})
  ble	{tag 5:130}, ebp, G5/ebx

#() [110->120] (level:2) is #f with stack state #f
#({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130})
  ld	N7/edx, ebp, 4
  beq	{tag 9:125}, N7/edx, esi

#() [120->125] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  sub	ebp, ebp, 4

#() [345->350] (level:0) is #f with stack state #f
#()
  bra	{tag 8:105}

#({tag 2:170}) [170->175] (level:0) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 245})
  move	esi, 0

#({tag 3:175}) [175->245] (level:2) is #f with stack state #f
#({basic-block #() 245 285}, {basic-block #({tag 11:285}) 285 305})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 8
  push	9
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G9/eax, eax
  st	G9/eax, esp, 8
  ld	G10/edi, ebp, 8
  st-index	G10/edi, esp, 4, 8
  move	G8/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:285}, esi, 0

#() [245->285] (level:2) is #f with stack state #f
#({basic-block #({tag 10:305}) 305 315})
  ld	G11/edx, G0/ebx, 24
  push	{constant "KPfalseVKi"}
  push	G11/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:305}) [305->315] (level:2) is #f with stack state #f
#({basic-block #() 315 320})
  preserve-registers-exit	
  load-stack-arg-n	#t, N12/edi, 1

#() [315->320] (level:2) is #f with stack state #f
#()
  rts-and-drop	N12/edi

#({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f
#({basic-block #({tag 1:320}) 320 340})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:320}) [320->340] (level:1) is #f with stack state #f
#({basic-block #() 340 345})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [340->345] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:130}) [130->150] (level:2) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 245})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [350->355] (level:0) is #f with stack state #f
#()
  bra	{tag 3:175}

#({tag 9:125}) [125->130] (level:2) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  sub	N6/edi, N6/edi, 8

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

#({tag 11:285}) [285->305] (level:2) is #f with stack state #f
#({basic-block #({tag 10:305}) 305 315})
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [360->365] (level:0) is #f with stack state #f
#()
  bra	{tag 10:305}

+++ ending code for explicit_keyed_single_method_entry_1 +++

+++ Live variable scopes for explicit_keyed_single_method_entry_1 +++
Start scope at 68 with frame for no variables
End scope at 120

+++ No Source Code Locators for explicit_keyed_single_method_entry_1 +++


+++ Exported function definition explicit_keyed_single_method_entry_2 +++

+++ starting code for explicit_keyed_single_method_entry_2 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, G2/edx, 1
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:170}, G4/edx, 4, 0

#() [30->80] (level:0) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  load-stack-arg-n	#t, G3/edx, 1
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G5/ebx, G0/ebx, 24
  ld	N6/edi, eax, 4
  sub	N6/edi, N6/edi, 1
  add	N6/edi, N6/edi, eax

#({tag 6:80}) [80->85] (level:1) is #f with stack state #f
#({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170})
  ble	{tag 7:150}, N6/edi, eax

#() [85->105] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  ld	esi, N6/edi, 0
  ld	ebp, G5/ebx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/ebx

#({tag 8:105}) [105->110] (level:2) is #f with stack state #f
#({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150})
  ble	{tag 5:130}, ebp, G5/ebx

#() [110->120] (level:2) is #f with stack state #f
#({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130})
  ld	N7/edx, ebp, 4
  beq	{tag 9:125}, N7/edx, esi

#() [120->125] (level:1) is #f with stack state #f
#({basic-block #({tag 8:105}) 105 110})
  sub	ebp, ebp, 4

#() [355->360] (level:0) is #f with stack state #f
#()
  bra	{tag 8:105}

#({tag 2:170}) [170->175] (level:0) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 255})
  move	esi, 0

#({tag 3:175}) [175->255] (level:2) is #f with stack state #f
#({basic-block #() 255 295}, {basic-block #({tag 11:295}) 295 315})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 12
  push	13
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G9/eax, eax
  st	G9/eax, esp, 8
  ld	G10/edi, ebp, 8
  st	G10/edi, esp, 12
  ld	G11/edi, ebp, 12
  st-index	G11/edi, esp, 8, 8
  move	G8/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:295}, esi, 0

#() [255->295] (level:2) is #f with stack state #f
#({basic-block #({tag 10:315}) 315 325})
  ld	G12/edx, G0/ebx, 24
  push	{constant "KPfalseVKi"}
  push	G12/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:315}) [315->325] (level:2) is #f with stack state #f
#({basic-block #() 325 330})
  preserve-registers-exit	
  load-stack-arg-n	#t, N13/edi, 2

#() [325->330] (level:2) is #f with stack state #f
#()
  rts-and-drop	N13/edi

#({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f
#({basic-block #({tag 1:330}) 330 350})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:330}) [330->350] (level:1) is #f with stack state #f
#({basic-block #() 350 355})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [350->355] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:130}) [130->150] (level:2) is #f with stack state #f
#({basic-block #({tag 3:175}) 175 255})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [360->365] (level:0) is #f with stack state #f
#()
  bra	{tag 3:175}

#({tag 9:125}) [125->130] (level:2) is #f with stack state #f
#({basic-block #({tag 6:80}) 80 85})
  sub	N6/edi, N6/edi, 8

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

#({tag 11:295}) [295->315] (level:2) is #f with stack state #f
#({basic-block #({tag 10:315}) 315 325})
  push	G0/ebx
  push	G1/edi
  move	eax, G8/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [370->375] (level:0) is #f with stack state #f
#()
  bra	{tag 10:315}

+++ ending code for explicit_keyed_single_method_entry_2 +++

+++ Live variable scopes for explicit_keyed_single_method_entry_2 +++
Start scope at 68 with frame for no variables
End scope at 127

+++ No Source Code Locators for explicit_keyed_single_method_entry_2 +++


+++ Exported function definition explicit_keyed_single_method_entry +++

+++ starting code for explicit_keyed_single_method_entry +++

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

#() [5->55] (level:0) is #f with stack state #f
#({basic-block #() 55 130}, {basic-block #({tag 2:220}) 220 230})
  move	G0/ebx, ebx
  move	G1/edi, edi
  move	esi, G0/ebx
  ld	N5/ebx, G0/ebx, 4
  asr	N5/ebx, N5/ebx, 6
  and	N5/ebx, N5/ebx, 1020
  move	N6/ebx, N5/ebx
  ld	G2/ebx, esp, N6/ebx
  ld	G4/ebx, G2/ebx, 4
  bit	{tag 2:220}, G4/ebx, 4, 0

#() [55->130] (level:0) is #f with stack state #f
#({basic-block #({tag 6:130}) 130 135})
  move	G0/ebx, esi
  ld	N7/edx, G0/ebx, 4
  asr	N7/edx, N7/edx, 6
  and	N7/edx, N7/edx, 1020
  move	N8/edx, N7/edx
  ld	G3/edx, esp, N8/edx
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G9/ebx, G0/ebx, 24
  ld	N10/edi, eax, 4
  sub	N10/edi, N10/edi, 1
  add	N10/edi, N10/edi, eax

#({tag 6:130}) [130->135] (level:1) is #f with stack state #f
#({basic-block #() 135 155}, {basic-block #({tag 4:200}, {tag 7:200}) 200 220})
  ble	{tag 7:200}, N10/edi, eax

#() [135->155] (level:1) is #f with stack state #f
#({basic-block #({tag 8:155}) 155 160})
  ld	esi, N10/edi, 0
  ld	ebp, G9/ebx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G9/ebx

#({tag 8:155}) [155->160] (level:2) is #f with stack state #f
#({basic-block #() 160 170}, {basic-block #({tag 5:180}) 180 200})
  ble	{tag 5:180}, ebp, G9/ebx

#() [160->170] (level:2) is #f with stack state #f
#({basic-block #() 170 175}, {basic-block #({tag 9:175}) 175 180})
  ld	N11/edx, ebp, 4
  beq	{tag 9:175}, N11/edx, esi

#() [170->175] (level:1) is #f with stack state #f
#({basic-block #({tag 8:155}) 155 160})
  sub	ebp, ebp, 4

#() [490->495] (level:0) is #f with stack state #f
#()
  bra	{tag 8:155}

#({tag 2:220}) [220->230] (level:0) is #f with stack state #f
#({basic-block #({tag 3:230}) 230 380})
  move	G0/ebx, esi
  move	esi, 0

#({tag 3:230}) [230->380] (level:2) is #f with stack state #f
#({basic-block #() 380 420}, {basic-block #({tag 11:420}) 420 440})
  ld	N13/edx, G0/ebx, 4
  asr	N13/edx, N13/edx, 6
  and	N13/edx, N13/edx, 1020
  preserve-registers-entry	
  push	G1/edi
  push	G0/ebx
  push	esi
  add	N14/edi, N13/edx, 4
  sub	esp, esp, N14/edi
  add	G15/edi, N14/edi, 1
  push	G15/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G16/eax, eax
  st	G16/eax, esp, 8
  add	esi, ebp, 8
  add	N17/edi, esp, 12
  asr	N18/ecx, N13/edx, 2
  sub	N18/ecx, N18/ecx, 1
  move	edi, N17/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N18/ecx
  add	N20/edi, N13/edx, 4
  ld	G19/edi, ebp, N20/edi
  st-index	G19/edi, esp, N13/edx, 8
  move	G12/eax, esp
  ld	esi, ebp, -12
  push	N13/edx
  ld	G0/ebx, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:420}, esi, 0

#() [380->420] (level:2) is #f with stack state #f
#({basic-block #({tag 10:440}) 440 460})
  ld	G21/edx, G0/ebx, 24
  push	{constant "KPfalseVKi"}
  push	G21/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G12/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:440}) [440->460] (level:2) is #f with stack state #f
#({basic-block #() 460 465})
  pop	N13/edx
  preserve-registers-exit	
  add	N23/edx, N13/edx, 4
  ld	N22/edx, esp, N23/edx

#() [460->465] (level:2) is #f with stack state #f
#()
  rts-and-drop	N22/edx

#({tag 4:200}, {tag 7:200}) [200->220] (level:1) is #f with stack state #f
#({basic-block #({tag 1:465}) 465 485})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:465}) [465->485] (level:1) is #f with stack state #f
#({basic-block #() 485 490})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [485->490] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:180}) [180->200] (level:2) is #f with stack state #f
#({basic-block #({tag 3:230}) 230 380})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [495->500] (level:0) is #f with stack state #f
#()
  bra	{tag 3:230}

#({tag 9:175}) [175->180] (level:2) is #f with stack state #f
#({basic-block #({tag 6:130}) 130 135})
  sub	N10/edi, N10/edi, 8

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

#({tag 11:420}) [420->440] (level:2) is #f with stack state #f
#({basic-block #({tag 10:440}) 440 460})
  push	G0/ebx
  push	G1/edi
  move	eax, G12/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [505->510] (level:0) is #f with stack state #f
#()
  bra	{tag 10:440}

+++ ending code for explicit_keyed_single_method_entry +++

+++ Live variable scopes for explicit_keyed_single_method_entry +++
Start scope at 120 with frame for no variables
End scope at 203

+++ No Source Code Locators for explicit_keyed_single_method_entry +++


+++ Exported function definition implicit_keyed_single_method_entry_0 +++

+++ starting code for implicit_keyed_single_method_entry_0 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180})
  move	G0/ebx, ebx
  move	G1/edi, edi
  move	G2/edx, eax
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:175}, G4/edx, 4, 0

#() [30->85] (level:0) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  move	G3/edx, eax
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G6/ebx, G0/ebx, 16
  ld	G5/edx, G6/ebx, 20
  ld	N7/edi, eax, 4
  sub	N7/edi, N7/edi, 1
  add	N7/edi, N7/edi, eax

#({tag 6:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175})
  ble	{tag 7:155}, N7/edi, eax

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  ld	esi, N7/edi, 0
  ld	ebp, G5/edx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/edx

#({tag 8:110}) [110->115] (level:2) is #f with stack state #f
#({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155})
  ble	{tag 5:135}, ebp, G5/edx

#() [115->125] (level:2) is #f with stack state #f
#({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135})
  ld	N8/ebx, ebp, 0
  beq	{tag 9:130}, N8/ebx, esi

#() [125->130] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  sub	ebp, ebp, 8

#() [345->350] (level:0) is #f with stack state #f
#()
  bra	{tag 8:110}

#({tag 2:175}) [175->180] (level:0) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 240})
  move	esi, 0

#({tag 3:180}) [180->240] (level:2) is #f with stack state #f
#({basic-block #() 240 285}, {basic-block #({tag 11:285}) 285 305})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 4
  push	5
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G10/eax, eax
  st-index	G10/eax, esp, 0, 8
  move	G9/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:285}, esi, 0

#() [240->285] (level:2) is #f with stack state #f
#({basic-block #({tag 10:305}) 305 315})
  ld	G12/edx, G0/ebx, 16
  ld	G11/edx, G12/edx, 20
  push	{constant "KPtrueVKi"}
  push	G11/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:305}) [305->315] (level:2) is #f with stack state #f
#({basic-block #() 315 320})
  preserve-registers-exit	
  load-stack-arg-n	#t, N13/edi, 0

#() [315->320] (level:2) is #f with stack state #f
#()
  rts-and-drop	N13/edi

#({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f
#({basic-block #({tag 1:320}) 320 340})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:320}) [320->340] (level:1) is #f with stack state #f
#({basic-block #() 340 345})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [340->345] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:135}) [135->155] (level:2) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 240})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [350->355] (level:0) is #f with stack state #f
#()
  bra	{tag 3:180}

#({tag 9:130}) [130->135] (level:2) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  sub	N7/edi, N7/edi, 8

#() [355->360] (level:0) is #f with stack state #f
#()
  bra	{tag 6:85}

#({tag 11:285}) [285->305] (level:2) is #f with stack state #f
#({basic-block #({tag 10:305}) 305 315})
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [360->365] (level:0) is #f with stack state #f
#()
  bra	{tag 10:305}

+++ ending code for implicit_keyed_single_method_entry_0 +++

+++ Live variable scopes for implicit_keyed_single_method_entry_0 +++
Start scope at 67 with frame for no variables
End scope at 115

+++ No Source Code Locators for implicit_keyed_single_method_entry_0 +++


+++ Exported function definition implicit_keyed_single_method_entry_1 +++

+++ starting code for implicit_keyed_single_method_entry_1 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, G2/edx, 0
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:175}, G4/edx, 4, 0

#() [30->85] (level:0) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  load-stack-arg-n	#t, G3/edx, 0
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G6/ebx, G0/ebx, 16
  ld	G5/edx, G6/ebx, 20
  ld	N7/edi, eax, 4
  sub	N7/edi, N7/edi, 1
  add	N7/edi, N7/edi, eax

#({tag 6:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175})
  ble	{tag 7:155}, N7/edi, eax

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  ld	esi, N7/edi, 0
  ld	ebp, G5/edx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/edx

#({tag 8:110}) [110->115] (level:2) is #f with stack state #f
#({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155})
  ble	{tag 5:135}, ebp, G5/edx

#() [115->125] (level:2) is #f with stack state #f
#({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135})
  ld	N8/ebx, ebp, 0
  beq	{tag 9:130}, N8/ebx, esi

#() [125->130] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  sub	ebp, ebp, 8

#() [355->360] (level:0) is #f with stack state #f
#()
  bra	{tag 8:110}

#({tag 2:175}) [175->180] (level:0) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 250})
  move	esi, 0

#({tag 3:180}) [180->250] (level:2) is #f with stack state #f
#({basic-block #() 250 295}, {basic-block #({tag 11:295}) 295 315})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 8
  push	9
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G10/eax, eax
  st	G10/eax, esp, 8
  ld	G11/edi, ebp, 8
  st-index	G11/edi, esp, 4, 8
  move	G9/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:295}, esi, 0

#() [250->295] (level:2) is #f with stack state #f
#({basic-block #({tag 10:315}) 315 325})
  ld	G13/edx, G0/ebx, 16
  ld	G12/edx, G13/edx, 20
  push	{constant "KPtrueVKi"}
  push	G12/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:315}) [315->325] (level:2) is #f with stack state #f
#({basic-block #() 325 330})
  preserve-registers-exit	
  load-stack-arg-n	#t, N14/edi, 1

#() [325->330] (level:2) is #f with stack state #f
#()
  rts-and-drop	N14/edi

#({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f
#({basic-block #({tag 1:330}) 330 350})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:330}) [330->350] (level:1) is #f with stack state #f
#({basic-block #() 350 355})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [350->355] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:135}) [135->155] (level:2) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 250})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [360->365] (level:0) is #f with stack state #f
#()
  bra	{tag 3:180}

#({tag 9:130}) [130->135] (level:2) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  sub	N7/edi, N7/edi, 8

#() [365->370] (level:0) is #f with stack state #f
#()
  bra	{tag 6:85}

#({tag 11:295}) [295->315] (level:2) is #f with stack state #f
#({basic-block #({tag 10:315}) 315 325})
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [370->375] (level:0) is #f with stack state #f
#()
  bra	{tag 10:315}

+++ ending code for implicit_keyed_single_method_entry_1 +++

+++ Live variable scopes for implicit_keyed_single_method_entry_1 +++
Start scope at 71 with frame for no variables
End scope at 126

+++ No Source Code Locators for implicit_keyed_single_method_entry_1 +++


+++ Exported function definition implicit_keyed_single_method_entry_2 +++

+++ starting code for implicit_keyed_single_method_entry_2 +++

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

#() [5->30] (level:0) is #f with stack state #f
#({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180})
  move	G0/ebx, ebx
  move	G1/edi, edi
  load-stack-arg-n	#t, G2/edx, 1
  ld	G4/edx, G2/edx, 4
  bit	{tag 2:175}, G4/edx, 4, 0

#() [30->85] (level:0) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  load-stack-arg-n	#t, G3/edx, 1
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G6/ebx, G0/ebx, 16
  ld	G5/edx, G6/ebx, 20
  ld	N7/edi, eax, 4
  sub	N7/edi, N7/edi, 1
  add	N7/edi, N7/edi, eax

#({tag 6:85}) [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175})
  ble	{tag 7:155}, N7/edi, eax

#() [90->110] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  ld	esi, N7/edi, 0
  ld	ebp, G5/edx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G5/edx

#({tag 8:110}) [110->115] (level:2) is #f with stack state #f
#({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155})
  ble	{tag 5:135}, ebp, G5/edx

#() [115->125] (level:2) is #f with stack state #f
#({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135})
  ld	N8/ebx, ebp, 0
  beq	{tag 9:130}, N8/ebx, esi

#() [125->130] (level:1) is #f with stack state #f
#({basic-block #({tag 8:110}) 110 115})
  sub	ebp, ebp, 8

#() [365->370] (level:0) is #f with stack state #f
#()
  bra	{tag 8:110}

#({tag 2:175}) [175->180] (level:0) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 260})
  move	esi, 0

#({tag 3:180}) [180->260] (level:2) is #f with stack state #f
#({basic-block #() 260 305}, {basic-block #({tag 11:305}) 305 325})
  preserve-registers-entry	
  push	G1/edi
  push	esi
  sub	esp, esp, 12
  push	13
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G10/eax, eax
  st	G10/eax, esp, 8
  ld	G11/edi, ebp, 8
  st	G11/edi, esp, 12
  ld	G12/edi, ebp, 12
  st-index	G12/edi, esp, 8, 8
  move	G9/eax, esp
  ld	esi, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:305}, esi, 0

#() [260->305] (level:2) is #f with stack state #f
#({basic-block #({tag 10:325}) 325 335})
  ld	G14/edx, G0/ebx, 16
  ld	G13/edx, G14/edx, 20
  push	{constant "KPtrueVKi"}
  push	G13/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:325}) [325->335] (level:2) is #f with stack state #f
#({basic-block #() 335 340})
  preserve-registers-exit	
  load-stack-arg-n	#t, N15/edi, 2

#() [335->340] (level:2) is #f with stack state #f
#()
  rts-and-drop	N15/edi

#({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f
#({basic-block #({tag 1:340}) 340 360})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:340}) [340->360] (level:1) is #f with stack state #f
#({basic-block #() 360 365})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [360->365] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:135}) [135->155] (level:2) is #f with stack state #f
#({basic-block #({tag 3:180}) 180 260})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [370->375] (level:0) is #f with stack state #f
#()
  bra	{tag 3:180}

#({tag 9:130}) [130->135] (level:2) is #f with stack state #f
#({basic-block #({tag 6:85}) 85 90})
  sub	N7/edi, N7/edi, 8

#() [375->380] (level:0) is #f with stack state #f
#()
  bra	{tag 6:85}

#({tag 11:305}) [305->325] (level:2) is #f with stack state #f
#({basic-block #({tag 10:325}) 325 335})
  push	G0/ebx
  push	G1/edi
  move	eax, G9/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [380->385] (level:0) is #f with stack state #f
#()
  bra	{tag 10:325}

+++ ending code for implicit_keyed_single_method_entry_2 +++

+++ Live variable scopes for implicit_keyed_single_method_entry_2 +++
Start scope at 71 with frame for no variables
End scope at 133

+++ No Source Code Locators for implicit_keyed_single_method_entry_2 +++


+++ Exported function definition implicit_keyed_single_method_entry +++

+++ starting code for implicit_keyed_single_method_entry +++

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

#() [5->55] (level:0) is #f with stack state #f
#({basic-block #() 55 135}, {basic-block #({tag 2:225}) 225 235})
  move	G0/ebx, ebx
  move	G1/edi, edi
  move	esi, G0/ebx
  ld	N5/ebx, G0/ebx, 4
  asr	N5/ebx, N5/ebx, 6
  and	N5/ebx, N5/ebx, 1020
  move	N6/ebx, N5/ebx
  ld	G2/ebx, esp, N6/ebx
  ld	G4/ebx, G2/ebx, 4
  bit	{tag 2:225}, G4/ebx, 4, 0

#() [55->135] (level:0) is #f with stack state #f
#({basic-block #({tag 6:135}) 135 140})
  move	G0/ebx, esi
  ld	N7/edx, G0/ebx, 4
  asr	N7/edx, N7/edx, 6
  and	N7/edx, N7/edx, 1020
  move	N8/edx, N7/edx
  ld	G3/edx, esp, N8/edx
  push	eax
  push	ebp
  push	G0/ebx
  push	G1/edi
  move	eax, G3/edx
  ld	G10/ebx, G0/ebx, 16
  ld	G9/edx, G10/ebx, 20
  ld	N11/edi, eax, 4
  sub	N11/edi, N11/edi, 1
  add	N11/edi, N11/edi, eax

#({tag 6:135}) [135->140] (level:1) is #f with stack state #f
#({basic-block #() 140 160}, {basic-block #({tag 4:205}, {tag 7:205}) 205 225})
  ble	{tag 7:205}, N11/edi, eax

#() [140->160] (level:1) is #f with stack state #f
#({basic-block #({tag 8:160}) 160 165})
  ld	esi, N11/edi, 0
  ld	ebp, G9/edx, 4
  sub	ebp, ebp, 1
  add	ebp, ebp, G9/edx

#({tag 8:160}) [160->165] (level:2) is #f with stack state #f
#({basic-block #() 165 175}, {basic-block #({tag 5:185}) 185 205})
  ble	{tag 5:185}, ebp, G9/edx

#() [165->175] (level:2) is #f with stack state #f
#({basic-block #() 175 180}, {basic-block #({tag 9:180}) 180 185})
  ld	N12/ebx, ebp, 0
  beq	{tag 9:180}, N12/ebx, esi

#() [175->180] (level:1) is #f with stack state #f
#({basic-block #({tag 8:160}) 160 165})
  sub	ebp, ebp, 8

#() [500->505] (level:0) is #f with stack state #f
#()
  bra	{tag 8:160}

#({tag 2:225}) [225->235] (level:0) is #f with stack state #f
#({basic-block #({tag 3:235}) 235 385})
  move	G0/ebx, esi
  move	esi, 0

#({tag 3:235}) [235->385] (level:2) is #f with stack state #f
#({basic-block #() 385 430}, {basic-block #({tag 11:430}) 430 450})
  ld	N14/edx, G0/ebx, 4
  asr	N14/edx, N14/edx, 6
  and	N14/edx, N14/edx, 1020
  preserve-registers-entry	
  push	G1/edi
  push	G0/ebx
  push	esi
  add	N15/edi, N14/edx, 4
  sub	esp, esp, N15/edi
  add	G16/edi, N15/edi, 1
  push	G16/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  move	G17/eax, eax
  st	G17/eax, esp, 8
  add	esi, ebp, 8
  add	N18/edi, esp, 12
  asr	N19/ecx, N14/edx, 2
  sub	N19/ecx, N19/ecx, 1
  move	edi, N18/edi
  move	esi, esi
  copy-words-down-w	edi, esi, N19/ecx
  add	N21/edi, N14/edx, 4
  ld	G20/edi, ebp, N21/edi
  st-index	G20/edi, esp, N14/edx, 8
  move	G13/eax, esp
  ld	esi, ebp, -12
  push	N14/edx
  ld	G0/ebx, ebp, -8
  ld	G1/edi, ebp, -4
  beq	{tag 11:430}, esi, 0

#() [385->430] (level:2) is #f with stack state #f
#({basic-block #({tag 10:450}) 450 470})
  ld	G23/edx, G0/ebx, 16
  ld	G22/edx, G23/edx, 20
  push	{constant "KPtrueVKi"}
  push	G22/edx
  push	esi
  push	G0/ebx
  push	G1/edi
  move	eax, G13/eax
  call	{constant "Kinvalid_keyword_trapVKeI"}, 1

#({tag 10:450}) [450->470] (level:2) is #f with stack state #f
#({basic-block #() 470 475})
  pop	N14/edx
  preserve-registers-exit	
  add	N25/edx, N14/edx, 4
  ld	N24/edx, esp, N25/edx

#() [470->475] (level:2) is #f with stack state #f
#()
  rts-and-drop	N24/edx

#({tag 4:205}, {tag 7:205}) [205->225] (level:1) is #f with stack state #f
#({basic-block #({tag 1:475}) 475 495})
  add	esp, esp, 4
  pop	G0/ebx
  pop	ebp
  pop	eax

#({tag 1:475}) [475->495] (level:1) is #f with stack state #f
#({basic-block #() 495 500})
  ld	G1/edi, G0/ebx, 20
  ld	G0/ebx, G0/ebx, 16
  move	ebx, G0/ebx
  move	edi, G1/edi

#() [495->500] (level:1) is #f with stack state #f
#()
  jmp-indirect	ebx, 12, 1, 0, #f, #f

#({tag 5:185}) [185->205] (level:2) is #f with stack state #f
#({basic-block #({tag 3:235}) 235 385})
  pop	G1/edi
  pop	G0/ebx
  pop	ebp
  pop	eax

#() [505->510] (level:0) is #f with stack state #f
#()
  bra	{tag 3:235}

#({tag 9:180}) [180->185] (level:2) is #f with stack state #f
#({basic-block #({tag 6:135}) 135 140})
  sub	N11/edi, N11/edi, 8

#() [510->515] (level:0) is #f with stack state #f
#()
  bra	{tag 6:135}

#({tag 11:430}) [430->450] (level:2) is #f with stack state #f
#({basic-block #({tag 10:450}) 450 470})
  push	G0/ebx
  push	G1/edi
  move	eax, G13/eax
  call	{constant "Kodd_number_of_keyword_args_trapVKeI"}, 1

#() [515->520] (level:0) is #f with stack state #f
#()
  bra	{tag 10:450}

+++ ending code for implicit_keyed_single_method_entry +++

+++ Live variable scopes for implicit_keyed_single_method_entry +++
Start scope at 123 with frame for no variables
End scope at 209

+++ No Source Code Locators for implicit_keyed_single_method_entry +++


+++ Exported function definition discriminate_on_argument_entry_0 +++

+++ starting code for discriminate_on_argument_entry_0 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  move	G0/ecx, eax
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_0 +++

+++ No Source Code Locators for discriminate_on_argument_entry_0 +++


+++ Exported function definition discriminate_on_argument_entry_1 +++

+++ starting code for discriminate_on_argument_entry_1 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 0
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_1 +++

+++ No Source Code Locators for discriminate_on_argument_entry_1 +++


+++ Exported function definition discriminate_on_argument_entry_2 +++

+++ starting code for discriminate_on_argument_entry_2 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 1
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_2 +++

+++ No Source Code Locators for discriminate_on_argument_entry_2 +++


+++ Exported function definition discriminate_on_argument_entry_3 +++

+++ starting code for discriminate_on_argument_entry_3 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 2
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_3 +++

+++ No Source Code Locators for discriminate_on_argument_entry_3 +++


+++ Exported function definition discriminate_on_argument_entry_4 +++

+++ starting code for discriminate_on_argument_entry_4 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 3
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_4 +++

+++ No Source Code Locators for discriminate_on_argument_entry_4 +++


+++ Exported function definition discriminate_on_argument_entry_5 +++

+++ starting code for discriminate_on_argument_entry_5 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 4
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_5 +++

+++ No Source Code Locators for discriminate_on_argument_entry_5 +++


+++ Exported function definition discriminate_on_argument_entry_6 +++

+++ starting code for discriminate_on_argument_entry_6 +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 65})
  load-stack-arg-n	#t, G0/ecx, 5
  push	eax
  push	edi
  ld	N1/edx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/ecx
  call	N1/edx, 1

#() [45->65] (level:0) is #f with stack state #f
#({basic-block #() 65 70})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [65->70] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry_6 +++

+++ No Source Code Locators for discriminate_on_argument_entry_6 +++


+++ Exported function definition discriminate_on_argument_entry +++

+++ starting code for discriminate_on_argument_entry +++

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

#() [5->65] (level:0) is #f with stack state #f
#({basic-block #() 65 85})
  ld	N3/edx, ebx, 4
  asr	N3/edx, N3/edx, 6
  and	N3/edx, N3/edx, 1020
  move	N4/edx, N3/edx
  ld	G0/edx, esp, N4/edx
  push	eax
  push	edi
  ld	N1/ecx, ebx, 8
  push	ebx
  push	edi
  move	eax, G0/edx
  call	N1/ecx, 1

#() [65->85] (level:0) is #f with stack state #f
#({basic-block #() 85 90})
  move	ebx, eax
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [85->90] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for discriminate_on_argument_entry +++

+++ No Source Code Locators for discriminate_on_argument_entry +++


+++ Exported function definition if_type_discriminator_engine_0 +++

+++ starting code for if_type_discriminator_engine_0 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  move	G0/edx, eax
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_0 +++

+++ No Source Code Locators for if_type_discriminator_engine_0 +++


+++ Exported function definition if_type_discriminator_engine_1 +++

+++ starting code for if_type_discriminator_engine_1 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 0
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_1 +++

+++ No Source Code Locators for if_type_discriminator_engine_1 +++


+++ Exported function definition if_type_discriminator_engine_2 +++

+++ starting code for if_type_discriminator_engine_2 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 1
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_2 +++

+++ No Source Code Locators for if_type_discriminator_engine_2 +++


+++ Exported function definition if_type_discriminator_engine_3 +++

+++ starting code for if_type_discriminator_engine_3 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 2
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_3 +++

+++ No Source Code Locators for if_type_discriminator_engine_3 +++


+++ Exported function definition if_type_discriminator_engine_4 +++

+++ starting code for if_type_discriminator_engine_4 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 3
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_4 +++

+++ No Source Code Locators for if_type_discriminator_engine_4 +++


+++ Exported function definition if_type_discriminator_engine_5 +++

+++ starting code for if_type_discriminator_engine_5 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 4
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_5 +++

+++ No Source Code Locators for if_type_discriminator_engine_5 +++


+++ Exported function definition if_type_discriminator_engine_6 +++

+++ starting code for if_type_discriminator_engine_6 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 5
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for if_type_discriminator_engine_6 +++

+++ No Source Code Locators for if_type_discriminator_engine_6 +++


+++ Exported function definition if_type_discriminator_engine +++

+++ starting code for if_type_discriminator_engine +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 80}, {basic-block #({tag 1:95}) 95 105})
  ld	N3/edx, ebx, 4
  asr	N3/edx, N3/edx, 6
  and	N3/edx, N3/edx, 1020
  move	N4/edx, N3/edx
  ld	G0/edx, esp, N4/edx
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G6/edi, N1/edi
  beq	{tag 1:95}, G6/edi, {constant "KLobjectGVKd"}

#() [60->80] (level:0) is #f with stack state #f
#({basic-block #() 80 85})
  ld	N5/ebx, G6/edi, 4
  push	G6/edi
  move	eax, G0/edx
  call	N5/ebx, 1

#() [80->85] (level:0) is #f with stack state #f
#({basic-block #() 85 95}, {basic-block #({tag 1:95}) 95 105})
  bne	{tag 1:95}, eax, {constant "KPfalseVKi"}

#() [85->95] (level:0) is #f with stack state #f
#({basic-block #({tag 2:105}) 105 120})
  pop	ebx
  ld	ebx, ebx, 24

#({tag 2:105}) [105->120] (level:0) is #f with stack state #f
#({basic-block #() 120 125})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [120->125] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:95}) [95->105] (level:0) is #f with stack state #f
#({basic-block #({tag 2:105}) 105 120})
  pop	ebx
  ld	ebx, ebx, 20

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

+++ ending code for if_type_discriminator_engine +++

+++ No Source Code Locators for if_type_discriminator_engine +++


+++ Exported function definition typecheck_discriminator_engine_0 +++

+++ starting code for typecheck_discriminator_engine_0 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  move	G0/edx, eax
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_0 +++

+++ No Source Code Locators for typecheck_discriminator_engine_0 +++


+++ Exported function definition typecheck_discriminator_engine_1 +++

+++ starting code for typecheck_discriminator_engine_1 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 0
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_1 +++

+++ No Source Code Locators for typecheck_discriminator_engine_1 +++


+++ Exported function definition typecheck_discriminator_engine_2 +++

+++ starting code for typecheck_discriminator_engine_2 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 1
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_2 +++

+++ No Source Code Locators for typecheck_discriminator_engine_2 +++


+++ Exported function definition typecheck_discriminator_engine_3 +++

+++ starting code for typecheck_discriminator_engine_3 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 2
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_3 +++

+++ No Source Code Locators for typecheck_discriminator_engine_3 +++


+++ Exported function definition typecheck_discriminator_engine_4 +++

+++ starting code for typecheck_discriminator_engine_4 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 3
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_4 +++

+++ No Source Code Locators for typecheck_discriminator_engine_4 +++


+++ Exported function definition typecheck_discriminator_engine_5 +++

+++ starting code for typecheck_discriminator_engine_5 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 4
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_5 +++

+++ No Source Code Locators for typecheck_discriminator_engine_5 +++


+++ Exported function definition typecheck_discriminator_engine_6 +++

+++ starting code for typecheck_discriminator_engine_6 +++

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

#() [5->40] (level:0) is #f with stack state #f
#({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85})
  load-stack-arg-n	#t, G0/edx, 5
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G4/edi, N1/edi
  beq	{tag 1:75}, G4/edi, {constant "KLobjectGVKd"}

#() [40->60] (level:0) is #f with stack state #f
#({basic-block #() 60 65})
  ld	N3/ebx, G4/edi, 4
  push	G4/edi
  move	eax, G0/edx
  call	N3/ebx, 1

#() [60->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85})
  bne	{tag 1:75}, eax, {constant "KPfalseVKi"}

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:85}) [85->100] (level:0) is #f with stack state #f
#({basic-block #() 100 105})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [100->105] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->85] (level:0) is #f with stack state #f
#({basic-block #({tag 2:85}) 85 100})
  pop	ebx
  ld	ebx, ebx, 20

#() [105->110] (level:0) is #f with stack state #f
#()
  bra	{tag 2:85}

+++ ending code for typecheck_discriminator_engine_6 +++

+++ No Source Code Locators for typecheck_discriminator_engine_6 +++


+++ Exported function definition typecheck_discriminator_engine +++

+++ starting code for typecheck_discriminator_engine +++

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

#() [5->60] (level:0) is #f with stack state #f
#({basic-block #() 60 80}, {basic-block #({tag 1:95}) 95 105})
  ld	N3/edx, ebx, 4
  asr	N3/edx, N3/edx, 6
  and	N3/edx, N3/edx, 1020
  move	N4/edx, N3/edx
  ld	G0/edx, esp, N4/edx
  push	eax
  push	edi
  ld	N1/edi, ebx, 16
  push	ebx
  move	G6/edi, N1/edi
  beq	{tag 1:95}, G6/edi, {constant "KLobjectGVKd"}

#() [60->80] (level:0) is #f with stack state #f
#({basic-block #() 80 85})
  ld	N5/ebx, G6/edi, 4
  push	G6/edi
  move	eax, G0/edx
  call	N5/ebx, 1

#() [80->85] (level:0) is #f with stack state #f
#({basic-block #() 85 95}, {basic-block #({tag 1:95}) 95 105})
  bne	{tag 1:95}, eax, {constant "KPfalseVKi"}

#() [85->95] (level:0) is #f with stack state #f
#({basic-block #({tag 2:105}) 105 120})
  pop	ebx
  move	ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"}

#({tag 2:105}) [105->120] (level:0) is #f with stack state #f
#({basic-block #() 120 125})
  pop	edi
  pop	eax
  ld	N2/edx, ebx, 12

#() [120->125] (level:0) is #f with stack state #f
#()
  jmp	N2/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:95}) [95->105] (level:0) is #f with stack state #f
#({basic-block #({tag 2:105}) 105 120})
  pop	ebx
  ld	ebx, ebx, 20

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

+++ ending code for typecheck_discriminator_engine +++

+++ No Source Code Locators for typecheck_discriminator_engine +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_0 +++

+++ starting code for monomorphic_by_class_discriminator_engine_0 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  move	G0/ecx, eax
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_0 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_0 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_1 +++

+++ starting code for monomorphic_by_class_discriminator_engine_1 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 0
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_1 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_1 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_2 +++

+++ starting code for monomorphic_by_class_discriminator_engine_2 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 1
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_2 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_2 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_3 +++

+++ starting code for monomorphic_by_class_discriminator_engine_3 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 2
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_3 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_3 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_4 +++

+++ starting code for monomorphic_by_class_discriminator_engine_4 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 3
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_4 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_4 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_5 +++

+++ starting code for monomorphic_by_class_discriminator_engine_5 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 4
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_5 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_5 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine_6 +++

+++ starting code for monomorphic_by_class_discriminator_engine_6 +++

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

#() [5->25] (level:0) is #f with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 80})
  load-stack-arg-n	#t, G0/ecx, 5
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:75}, N1/edx, 0

#() [25->30] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:30}) [30->45] (level:0) is #f with stack state #f
#({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:60}, N1/edx, G0/ecx

#() [45->55] (level:0) is #f with stack state #f
#({basic-block #() 55 60})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [55->60] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:75}) [75->80] (level:0) is #f with stack state #f
#({basic-block #({tag 3:30}) 30 45})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

#({tag 2:60}) [60->70] (level:0) is #f with stack state #f
#({basic-block #() 70 75})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [70->75] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine_6 +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine_6 +++


+++ Exported function definition monomorphic_by_class_discriminator_engine +++

+++ starting code for monomorphic_by_class_discriminator_engine +++

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

#() [5->45] (level:0) is #f with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 1:95}) 95 100})
  ld	N2/ecx, ebx, 4
  asr	N2/ecx, N2/ecx, 6
  and	N2/ecx, N2/ecx, 1020
  move	N3/ecx, N2/ecx
  ld	G0/ecx, esp, N3/ecx
  move	N1/edx, G0/ecx
  and	N1/edx, N1/edx, 3
  bne	{tag 1:95}, N1/edx, 0

#() [45->50] (level:0) is #f with stack state #f
#({basic-block #({tag 3:50}) 50 65})
  ld	G0/ecx, G0/ecx, 0

#({tag 3:50}) [50->65] (level:0) is #f with stack state #f
#({basic-block #() 65 75}, {basic-block #({tag 2:80}) 80 90})
  or	G0/ecx, G0/ecx, 1
  ld	N1/edx, ebx, 16
  bne	{tag 2:80}, N1/edx, G0/ecx

#() [65->75] (level:0) is #f with stack state #f
#({basic-block #() 75 80})
  ld	ebx, ebx, 20
  ld	N1/edx, ebx, 12

#() [75->80] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:95}) [95->100] (level:0) is #f with stack state #f
#({basic-block #({tag 3:50}) 50 65})
  ld-index-scaled	G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0

#() [100->105] (level:0) is #f with stack state #f
#()
  bra	{tag 3:50}

#({tag 2:80}) [80->90] (level:0) is #f with stack state #f
#({basic-block #() 90 95})
  move	ebx, {indirect-constant "Dabsent_engine_nodeVKg"}
  ld	N1/edx, ebx, 12

#() [90->95] (level:0) is #f with stack state #f
#()
  jmp	N1/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for monomorphic_by_class_discriminator_engine +++

+++ No Source Code Locators for monomorphic_by_class_discriminator_engine +++


+++ Exported function definition general_engine_node_spread_entry +++

+++ starting code for general_engine_node_spread_entry +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #({tag 4:10}) 10 30})
  move	G2/ecx, edi

#({tag 4:10}) [10->30] (level:1) is #f with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 3:35}) 35 75})
  ld	N3/edx, G2/ecx, 0
  ld	N3/edx, N3/edx, 8
  and	N3/edx, N3/edx, 8192
  beq	{tag 3:35}, N3/edx, 0

#() [30->35] (level:1) is #f with stack state #f
#({basic-block #({tag 4:10}) 10 30})
  ld	G2/ecx, G2/ecx, 20

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

#({tag 3:35}) [35->75] (level:1) is #f with stack state #f
#({basic-block #() 75 85}, {basic-block #({tag 1:95}) 95 105})
  ld	N1/edx, G2/ecx, 8
  ld	N1/edx, N1/edx, 4
  asr	N1/edx, N1/edx, 2
  and	N1/edx, N1/edx, 255
  ld	N4/ecx, G2/ecx, 8
  ld	N4/ecx, N4/ecx, 4
  and	N4/ecx, N4/ecx, 1310720
  bne	{tag 1:95}, N4/ecx, 0

#() [75->85] (level:1) is #f with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n"}
  bge	{tag 5:115}, N1/edx, 1

#() [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 95}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  bne	{tag 6:115}, N1/edx, 0

#() [90->95] (level:1) is #f with stack state #f
#({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n_0"}

#({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) [115->115] (level:1) is #f with stack state #f
#({basic-block #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) 115 120})

#({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) [115->120] (level:1) is #f with stack state #f
#()
  jmp	N0/ecx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:95}) [95->105] (level:1) is #f with stack state #f
#({basic-block #() 105 110}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_spread_optionals"}
  bge	{tag 7:115}, N1/edx, 1

#() [105->110] (level:1) is #f with stack state #f
#({basic-block #() 110 115}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  bne	{tag 8:115}, N1/edx, 0

#() [110->115] (level:1) is #f with stack state #f
#({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_spread_optionals_0"}

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

+++ ending code for general_engine_node_spread_entry +++

+++ No Source Code Locators for general_engine_node_spread_entry +++


+++ Exported function definition general_engine_node_n_entry +++

+++ starting code for general_engine_node_n_entry +++

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

#() [5->10] (level:0) is #f with stack state #f
#({basic-block #({tag 4:10}) 10 30})
  move	G2/ecx, edi

#({tag 4:10}) [10->30] (level:1) is #f with stack state #f
#({basic-block #() 30 35}, {basic-block #({tag 3:35}) 35 75})
  ld	N3/edx, G2/ecx, 0
  ld	N3/edx, N3/edx, 8
  and	N3/edx, N3/edx, 8192
  beq	{tag 3:35}, N3/edx, 0

#() [30->35] (level:1) is #f with stack state #f
#({basic-block #({tag 4:10}) 10 30})
  ld	G2/ecx, G2/ecx, 20

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

#({tag 3:35}) [35->75] (level:1) is #f with stack state #f
#({basic-block #() 75 85}, {basic-block #({tag 1:95}) 95 105})
  ld	N1/edx, G2/ecx, 8
  ld	N1/edx, N1/edx, 4
  asr	N1/edx, N1/edx, 2
  and	N1/edx, N1/edx, 255
  ld	N4/ecx, G2/ecx, 8
  ld	N4/ecx, N4/ecx, 4
  and	N4/ecx, N4/ecx, 1310720
  bne	{tag 1:95}, N4/ecx, 0

#() [75->85] (level:1) is #f with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n"}
  bge	{tag 5:115}, N1/edx, 1

#() [85->90] (level:1) is #f with stack state #f
#({basic-block #() 90 95}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  bne	{tag 6:115}, N1/edx, 0

#() [90->95] (level:1) is #f with stack state #f
#({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n_0"}

#({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) [115->115] (level:1) is #f with stack state #f
#({basic-block #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) 115 120})

#({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) [115->120] (level:1) is #f with stack state #f
#()
  jmp	N0/ecx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:95}) [95->105] (level:1) is #f with stack state #f
#({basic-block #() 105 110}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n_optionals"}
  bge	{tag 7:115}, N1/edx, 1

#() [105->110] (level:1) is #f with stack state #f
#({basic-block #() 110 115}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  bne	{tag 8:115}, N1/edx, 0

#() [110->115] (level:1) is #f with stack state #f
#({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115})
  move	N0/ecx, {constant "general_engine_node_n_optionals_0"}

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

+++ ending code for general_engine_node_n_entry +++

+++ No Source Code Locators for general_engine_node_n_entry +++


+++ Exported function definition cache_header_entry +++

+++ starting code for cache_header_entry +++

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

#() [5->20] (level:0) is #f with stack state #f
#({basic-block #() 20 25})
  move	edi, ebx
  ld	ebx, edi, 16
  ld	N0/edx, ebx, 12

#() [20->25] (level:0) is #f with stack state #f
#()
  jmp	N0/edx, #[1, #"mlist", #"function"], 0, #f, #f

+++ ending code for cache_header_entry +++

+++ No Source Code Locators for cache_header_entry +++


+++ Exported function definition profiling_cache_header_entry +++

+++ starting code for profiling_cache_header_entry +++

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

#() [5->15] (level:0) is #f with stack state #f
#({basic-block #() 15 25}, {basic-block #({tag 2:25}) 25 35})
  move	edi, ebx
  beq	{tag 2:25}, {indirect-constant "Tdispatch_profiling_enabledQTVKe"}, {constant "KPfalseVKi"}

#() [15->25] (level:0) is #f with stack state #f
#({basic-block #({tag 2:25}) 25 35}, {basic-block #({tag 1:40}) 40 45})
  xadd-mem-locked	N0/edx, ebx, 24, 1
  beq	{tag 1:40}, N0/edx, 0

#({tag 2:25}) [25->35] (level:0) is #f with stack state #f
#({basic-block #() 35 40})
  ld	ebx, ebx, 16
  ld	N0/edx, ebx, 12

#() [35->40] (level:0) is #f with stack state #f
#()
  jmp	N0/edx, #[1, #"mlist", #"function"], 0, #f, #f

#({tag 1:40}) [40->45] (level:0) is #f with stack state #f
#({basic-block #({tag 2:25}) 25 35})
  add2-mem-locked	ebx, ebx, 28, 1

#() [45->50] (level:0) is #f with stack state #f
#()
  bra	{tag 2:25}

+++ ending code for profiling_cache_header_entry +++

+++ No Source Code Locators for profiling_cache_header_entry +++


+++ Exported function definition primitive_enable_cache_header_engine_node +++

+++ starting code for primitive_enable_cache_header_engine_node +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N1/edi, {constant "cache_header_entry"}
  st	N1/edi, G0/eax, 12
  move	eax, G0/eax

#() [25->30] (level:0) is green with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_enable_cache_header_engine_node +++

+++ No Source Code Locators for primitive_enable_cache_header_engine_node +++


+++ Exported function definition primitive_invalidate_cache_header_engine_node +++

+++ starting code for primitive_invalidate_cache_header_engine_node +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N1/edi, {constant "general_engine_node_n_entry"}
  st	N1/edi, G0/eax, 12
  move	eax, G0/eax

#() [25->30] (level:0) is green with stack state #f
#()
  rts-and-drop	4

+++ ending code for primitive_invalidate_cache_header_engine_node +++

+++ No Source Code Locators for primitive_invalidate_cache_header_engine_node +++


+++ Exported function definition initialize_engine_node_table_entries_1 +++

+++ starting code for initialize_engine_node_table_entries_1 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "general_engine_node_spread_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_1 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_1 +++


+++ Exported function definition initialize_engine_node_table_entries_2 +++

+++ starting code for initialize_engine_node_table_entries_2 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "single_method_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_2 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_2 +++


+++ Exported function definition initialize_engine_node_table_entries_3 +++

+++ starting code for initialize_engine_node_table_entries_3 +++

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

#() [5->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	G0/eax, eax
  ld	N1/edi, G0/eax, 4
  asr	N1/edi, N1/edi, 8
  and	N1/edi, N1/edi, 255
  move	N2/ebx, {constant "implicit_keyed_single_method_entry"}
  bge	{tag 1:65}, N1/edi, 3

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50})
  bne	{tag 2:45}, N1/edi, 0

#() [40->45] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "implicit_keyed_single_method_entry_0"}

#({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f
#({basic-block #() 75 80})
  st	N2/ebx, G0/eax, 12
  move	eax, G0/eax

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

#({tag 2:45}) [45->50] (level:0) is green with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60})
  bne	{tag 3:55}, N1/edi, 1

#() [50->55] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "implicit_keyed_single_method_entry_1"}

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

#({tag 3:55}) [55->60] (level:0) is green with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  bne	{tag 4:65}, N1/edi, 2

#() [60->65] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "implicit_keyed_single_method_entry_2"}

#() [85->90] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

+++ ending code for initialize_engine_node_table_entries_3 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_3 +++


+++ Exported function definition initialize_engine_node_table_entries_4 +++

+++ starting code for initialize_engine_node_table_entries_4 +++

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

#() [5->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	G0/eax, eax
  ld	N1/edi, G0/eax, 4
  asr	N1/edi, N1/edi, 8
  and	N1/edi, N1/edi, 255
  move	N2/ebx, {constant "explicit_keyed_single_method_entry"}
  bge	{tag 1:65}, N1/edi, 3

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50})
  bne	{tag 2:45}, N1/edi, 0

#() [40->45] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "explicit_keyed_single_method_entry_0"}

#({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f
#({basic-block #() 75 80})
  st	N2/ebx, G0/eax, 12
  move	eax, G0/eax

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

#({tag 2:45}) [45->50] (level:0) is green with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60})
  bne	{tag 3:55}, N1/edi, 1

#() [50->55] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "explicit_keyed_single_method_entry_1"}

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

#({tag 3:55}) [55->60] (level:0) is green with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  bne	{tag 4:65}, N1/edi, 2

#() [60->65] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "explicit_keyed_single_method_entry_2"}

#() [85->90] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

+++ ending code for initialize_engine_node_table_entries_4 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_4 +++


+++ Exported function definition initialize_engine_node_table_entries_5 +++

+++ starting code for initialize_engine_node_table_entries_5 +++

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

#() [5->35] (level:0) is green with stack state #f
#({basic-block #() 35 40}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	G0/eax, eax
  ld	N1/edi, G0/eax, 4
  asr	N1/edi, N1/edi, 8
  and	N1/edi, N1/edi, 255
  move	N2/ebx, {constant "unrestricted_keyed_single_method_entry"}
  bge	{tag 1:65}, N1/edi, 3

#() [35->40] (level:0) is green with stack state #f
#({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50})
  bne	{tag 2:45}, N1/edi, 0

#() [40->45] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "unrestricted_keyed_single_method_entry_0"}

#({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f
#({basic-block #() 75 80})
  st	N2/ebx, G0/eax, 12
  move	eax, G0/eax

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

#({tag 2:45}) [45->50] (level:0) is green with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60})
  bne	{tag 3:55}, N1/edi, 1

#() [50->55] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "unrestricted_keyed_single_method_entry_1"}

#() [80->85] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

#({tag 3:55}) [55->60] (level:0) is green with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  bne	{tag 4:65}, N1/edi, 2

#() [60->65] (level:0) is green with stack state #f
#({basic-block #({tag 1:65}, {tag 4:65}) 65 75})
  move	N2/ebx, {constant "unrestricted_keyed_single_method_entry_2"}

#() [85->90] (level:0) is #f with stack state #f
#()
  bra	{tag 1:65}

+++ ending code for initialize_engine_node_table_entries_5 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_5 +++


+++ Exported function definition initialize_engine_node_table_entries_13 +++

+++ starting code for initialize_engine_node_table_entries_13 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "profiling_cache_header_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_13 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_13 +++


+++ Exported function definition initialize_engine_node_table_entries_14 +++

+++ starting code for initialize_engine_node_table_entries_14 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "cache_header_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_14 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_14 +++


+++ Exported function definition initialize_engine_node_table_entries_16 +++

+++ starting code for initialize_engine_node_table_entries_16 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "boxed_instance_slot_getter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_16 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_16 +++


+++ Exported function definition initialize_engine_node_table_entries_17 +++

+++ starting code for initialize_engine_node_table_entries_17 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "boxed_instance_slot_setter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_17 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_17 +++


+++ Exported function definition initialize_engine_node_table_entries_18 +++

+++ starting code for initialize_engine_node_table_entries_18 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "boxed_repeated_instance_slot_getter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_18 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_18 +++


+++ Exported function definition initialize_engine_node_table_entries_19 +++

+++ starting code for initialize_engine_node_table_entries_19 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "boxed_repeated_instance_slot_setter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_19 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_19 +++


+++ Exported function definition initialize_engine_node_table_entries_22 +++

+++ starting code for initialize_engine_node_table_entries_22 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "raw_byte_repeated_instance_slot_getter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_22 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_22 +++


+++ Exported function definition initialize_engine_node_table_entries_23 +++

+++ starting code for initialize_engine_node_table_entries_23 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "raw_byte_repeated_instance_slot_setter_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_23 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_23 +++


+++ Exported function definition initialize_engine_node_table_entries_20 +++

+++ starting code for initialize_engine_node_table_entries_20 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "general_engine_node_1_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_20 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_20 +++


+++ Exported function definition initialize_engine_node_table_entries_21 +++

+++ starting code for initialize_engine_node_table_entries_21 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "general_engine_node_2_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_21 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_21 +++


+++ Exported function definition initialize_engine_node_table_entries_29 +++

+++ starting code for initialize_engine_node_table_entries_29 +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "general_engine_node_3_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_29 +++

+++ No Source Code Locators for initialize_engine_node_table_entries_29 +++


+++ Exported function definition initialize_engine_node_table_entries_default +++

+++ starting code for initialize_engine_node_table_entries_default +++

#() [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 #f
#({basic-block #() 25 30})
  move	G0/eax, eax
  move	N2/edi, {constant "general_engine_node_n_entry"}
  st	N2/edi, G0/eax, 12
  move	eax, G0/eax

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

+++ ending code for initialize_engine_node_table_entries_default +++

+++ No Source Code Locators for initialize_engine_node_table_entries_default +++


+++ Exported function definition primitive_initialize_engine_node +++

+++ starting code for primitive_initialize_engine_node +++

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

#() [5->20] (level:0) is green with stack state #f
#({basic-block #() 20 25})
  ld	N0/edi, eax, 4
  and	N0/edi, N0/edi, 252
  ld	N1/edi, {constant "Kinitialize_engine_node_table"}, N0/edi

#() [20->25] (level:0) is green with stack state #f
#()
  jmp	N1/edi, 1, 0, #f, #f

+++ ending code for primitive_initialize_engine_node +++

+++ No Source Code Locators for primitive_initialize_engine_node +++


+++ Exported function definition primitive_initialize_discriminator +++

+++ starting code for primitive_initialize_discriminator +++

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

#() [5->45] (level:0) is green with stack state #f
#({basic-block #() 45 50}, {basic-block #({tag 1:140}) 140 150})
  move	G0/eax, eax
  ld	N1/edi, G0/eax, 4
  asr	N1/edi, N1/edi, 8
  and	N1/edi, N1/edi, 255
  ld	N3/ebx, G0/eax, 4
  asr	N3/ebx, N3/ebx, 2
  and	N3/ebx, N3/ebx, 63
  beq	{tag 1:140}, N3/ebx, 33

#() [45->50] (level:0) is green with stack state #f
#({basic-block #() 50 55}, {basic-block #({tag 2:220}) 220 230})
  beq	{tag 2:220}, N3/ebx, 32

#() [50->55] (level:0) is green with stack state #f
#({basic-block #() 55 60}, {basic-block #({tag 3:300}) 300 310})
  beq	{tag 3:300}, N3/ebx, 42

#() [55->60] (level:0) is green with stack state #f
#({basic-block #() 60 70}, {basic-block #({tag 4:380}) 380 385})
  beq	{tag 4:380}, N3/ebx, 13

#() [60->70] (level:0) is green with stack state #f
#({basic-block #() 70 75}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry"}
  bge	{tag 6:385}, N1/edi, 7

#() [70->75] (level:0) is green with stack state #f
#({basic-block #() 75 80}, {basic-block #({tag 7:80}) 80 85})
  bne	{tag 7:80}, N1/edi, 0

#() [75->80] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_0"}

#({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) [385->395] (level:0) is green with stack state #f
#({basic-block #() 395 400})
  st	N2/ebx, G0/eax, 12
  move	eax, G0/eax

#() [395->400] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:140}) [140->150] (level:0) is green with stack state #f
#({basic-block #() 150 155}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine"}
  bge	{tag 14:385}, N1/edi, 7

#() [150->155] (level:0) is green with stack state #f
#({basic-block #() 155 160}, {basic-block #({tag 15:160}) 160 165})
  bne	{tag 15:160}, N1/edi, 0

#() [155->160] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_0"}

#() [400->405] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 2:220}) [220->230] (level:0) is green with stack state #f
#({basic-block #() 230 235}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine"}
  bge	{tag 22:385}, N1/edi, 7

#() [230->235] (level:0) is green with stack state #f
#({basic-block #() 235 240}, {basic-block #({tag 23:240}) 240 245})
  bne	{tag 23:240}, N1/edi, 0

#() [235->240] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_0"}

#() [405->410] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 3:300}) [300->310] (level:0) is green with stack state #f
#({basic-block #() 310 315}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine"}
  bge	{tag 30:385}, N1/edi, 7

#() [310->315] (level:0) is green with stack state #f
#({basic-block #() 315 320}, {basic-block #({tag 31:320}) 320 325})
  bne	{tag 31:320}, N1/edi, 0

#() [315->320] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_0"}

#() [410->415] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 4:380}) [380->385] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "profiling_cache_header_entry"}

#() [415->420] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 7:80}) [80->85] (level:0) is green with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 8:90}) 90 95})
  bne	{tag 8:90}, N1/edi, 1

#() [85->90] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_1"}

#() [420->425] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 15:160}) [160->165] (level:0) is green with stack state #f
#({basic-block #() 165 170}, {basic-block #({tag 16:170}) 170 175})
  bne	{tag 16:170}, N1/edi, 1

#() [165->170] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_1"}

#() [425->430] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 23:240}) [240->245] (level:0) is green with stack state #f
#({basic-block #() 245 250}, {basic-block #({tag 24:250}) 250 255})
  bne	{tag 24:250}, N1/edi, 1

#() [245->250] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_1"}

#() [430->435] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 31:320}) [320->325] (level:0) is green with stack state #f
#({basic-block #() 325 330}, {basic-block #({tag 32:330}) 330 335})
  bne	{tag 32:330}, N1/edi, 1

#() [325->330] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_1"}

#() [435->440] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 8:90}) [90->95] (level:0) is green with stack state #f
#({basic-block #() 95 100}, {basic-block #({tag 9:100}) 100 105})
  bne	{tag 9:100}, N1/edi, 2

#() [95->100] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_2"}

#() [440->445] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 16:170}) [170->175] (level:0) is green with stack state #f
#({basic-block #() 175 180}, {basic-block #({tag 17:180}) 180 185})
  bne	{tag 17:180}, N1/edi, 2

#() [175->180] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_2"}

#() [445->450] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 24:250}) [250->255] (level:0) is green with stack state #f
#({basic-block #() 255 260}, {basic-block #({tag 25:260}) 260 265})
  bne	{tag 25:260}, N1/edi, 2

#() [255->260] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_2"}

#() [450->455] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 32:330}) [330->335] (level:0) is green with stack state #f
#({basic-block #() 335 340}, {basic-block #({tag 33:340}) 340 345})
  bne	{tag 33:340}, N1/edi, 2

#() [335->340] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_2"}

#() [455->460] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 9:100}) [100->105] (level:0) is green with stack state #f
#({basic-block #() 105 110}, {basic-block #({tag 10:110}) 110 115})
  bne	{tag 10:110}, N1/edi, 3

#() [105->110] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_3"}

#() [460->465] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 17:180}) [180->185] (level:0) is green with stack state #f
#({basic-block #() 185 190}, {basic-block #({tag 18:190}) 190 195})
  bne	{tag 18:190}, N1/edi, 3

#() [185->190] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_3"}

#() [465->470] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 25:260}) [260->265] (level:0) is green with stack state #f
#({basic-block #() 265 270}, {basic-block #({tag 26:270}) 270 275})
  bne	{tag 26:270}, N1/edi, 3

#() [265->270] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_3"}

#() [470->475] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 33:340}) [340->345] (level:0) is green with stack state #f
#({basic-block #() 345 350}, {basic-block #({tag 34:350}) 350 355})
  bne	{tag 34:350}, N1/edi, 3

#() [345->350] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_3"}

#() [475->480] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 10:110}) [110->115] (level:0) is green with stack state #f
#({basic-block #() 115 120}, {basic-block #({tag 11:120}) 120 125})
  bne	{tag 11:120}, N1/edi, 4

#() [115->120] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_4"}

#() [480->485] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 18:190}) [190->195] (level:0) is green with stack state #f
#({basic-block #() 195 200}, {basic-block #({tag 19:200}) 200 205})
  bne	{tag 19:200}, N1/edi, 4

#() [195->200] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_4"}

#() [485->490] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 26:270}) [270->275] (level:0) is green with stack state #f
#({basic-block #() 275 280}, {basic-block #({tag 27:280}) 280 285})
  bne	{tag 27:280}, N1/edi, 4

#() [275->280] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_4"}

#() [490->495] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 34:350}) [350->355] (level:0) is green with stack state #f
#({basic-block #() 355 360}, {basic-block #({tag 35:360}) 360 365})
  bne	{tag 35:360}, N1/edi, 4

#() [355->360] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_4"}

#() [495->500] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 11:120}) [120->125] (level:0) is green with stack state #f
#({basic-block #() 125 130}, {basic-block #({tag 12:130}) 130 135})
  bne	{tag 12:130}, N1/edi, 5

#() [125->130] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_5"}

#() [500->505] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 19:200}) [200->205] (level:0) is green with stack state #f
#({basic-block #() 205 210}, {basic-block #({tag 20:210}) 210 215})
  bne	{tag 20:210}, N1/edi, 5

#() [205->210] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_5"}

#() [505->510] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 27:280}) [280->285] (level:0) is green with stack state #f
#({basic-block #() 285 290}, {basic-block #({tag 28:290}) 290 295})
  bne	{tag 28:290}, N1/edi, 5

#() [285->290] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_5"}

#() [510->515] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 35:360}) [360->365] (level:0) is green with stack state #f
#({basic-block #() 365 370}, {basic-block #({tag 36:370}) 370 375})
  bne	{tag 36:370}, N1/edi, 5

#() [365->370] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_5"}

#() [515->520] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 12:130}) [130->135] (level:0) is green with stack state #f
#({basic-block #() 135 140}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  bne	{tag 13:385}, N1/edi, 6

#() [135->140] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "discriminate_on_argument_entry_6"}

#() [520->525] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 20:210}) [210->215] (level:0) is green with stack state #f
#({basic-block #() 215 220}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  bne	{tag 21:385}, N1/edi, 6

#() [215->220] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "if_type_discriminator_engine_6"}

#() [525->530] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 28:290}) [290->295] (level:0) is green with stack state #f
#({basic-block #() 295 300}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  bne	{tag 29:385}, N1/edi, 6

#() [295->300] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "typecheck_discriminator_engine_6"}

#() [530->535] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

#({tag 36:370}) [370->375] (level:0) is green with stack state #f
#({basic-block #() 375 380}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  bne	{tag 37:385}, N1/edi, 6

#() [375->380] (level:0) is green with stack state #f
#({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395})
  move	N2/ebx, {constant "monomorphic_by_class_discriminator_engine_6"}

#() [535->540] (level:0) is #f with stack state #f
#()
  bra	{tag 5:385}

+++ ending code for primitive_initialize_discriminator +++

+++ No Source Code Locators for primitive_initialize_discriminator +++


+++ Exported function definition primitive_set_generic_function_entrypoints +++

+++ starting code for primitive_set_generic_function_entrypoints +++

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

#() [5->50] (level:0) is green with stack state #f
#({basic-block #() 50 60}, {basic-block #({tag 1:135}) 135 145})
  move	G0/eax, eax
  ld	N3/edi, G0/eax, 8
  ld	N3/edi, N3/edi, 4
  asr	N3/edi, N3/edi, 2
  and	N3/edi, N3/edi, 255
  ld	N4/ebx, G0/eax, 8
  ld	N4/ebx, N4/ebx, 4
  and	N4/ebx, N4/ebx, 1310720
  bne	{tag 1:135}, N4/ebx, 0

#() [50->60] (level:0) is green with stack state #f
#({basic-block #() 60 65}, {basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep"}
  bge	{tag 3:130}, N3/edi, 7

#() [60->65] (level:0) is green with stack state #f
#({basic-block #() 65 70}, {basic-block #({tag 4:70}) 70 75})
  bne	{tag 4:70}, N3/edi, 0

#() [65->70] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_0"}

#({tag 3:130}, {tag 10:130}) [130->135] (level:0) is green with stack state #f
#({basic-block #({tag 2:225}) 220 225})
  st	N2/ebx, G0/eax, 4

#({tag 2:225}) [220->225] (level:0) is green with stack state #f
#({basic-block #({tag 2:225}) 225 230})
  move	eax, G0/eax

#({tag 2:225}) [225->230] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 1:135}) [135->145] (level:0) is green with stack state #f
#({basic-block #() 145 150}, {basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep"}
  bge	{tag 11:215}, N3/edi, 7

#() [145->150] (level:0) is green with stack state #f
#({basic-block #() 150 155}, {basic-block #({tag 12:155}) 155 160})
  bne	{tag 12:155}, N3/edi, 0

#() [150->155] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_0"}

#({tag 11:215}, {tag 18:215}) [215->220] (level:0) is green with stack state #f
#({basic-block #({tag 2:225}) 220 225})
  st	N2/ebx, G0/eax, 4

#() [230->235] (level:0) is #f with stack state #f
#()
  bra	{tag 2:225}

#({tag 4:70}) [70->75] (level:0) is green with stack state #f
#({basic-block #() 75 80}, {basic-block #({tag 5:80}) 80 85})
  bne	{tag 5:80}, N3/edi, 1

#() [75->80] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_1"}

#() [235->240] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 12:155}) [155->160] (level:0) is green with stack state #f
#({basic-block #() 160 165}, {basic-block #({tag 13:165}) 165 170})
  bne	{tag 13:165}, N3/edi, 1

#() [160->165] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_1"}

#() [240->245] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

#({tag 5:80}) [80->85] (level:0) is green with stack state #f
#({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 95})
  bne	{tag 6:90}, N3/edi, 2

#() [85->90] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_2"}

#() [245->250] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 13:165}) [165->170] (level:0) is green with stack state #f
#({basic-block #() 170 175}, {basic-block #({tag 14:175}) 175 180})
  bne	{tag 14:175}, N3/edi, 2

#() [170->175] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_2"}

#() [250->255] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

#({tag 6:90}) [90->95] (level:0) is green with stack state #f
#({basic-block #() 95 100}, {basic-block #({tag 7:100}) 100 105})
  bne	{tag 7:100}, N3/edi, 3

#() [95->100] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_3"}

#() [255->260] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 14:175}) [175->180] (level:0) is green with stack state #f
#({basic-block #() 180 185}, {basic-block #({tag 15:185}) 185 190})
  bne	{tag 15:185}, N3/edi, 3

#() [180->185] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_3"}

#() [260->265] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

#({tag 7:100}) [100->105] (level:0) is green with stack state #f
#({basic-block #() 105 110}, {basic-block #({tag 8:110}) 110 115})
  bne	{tag 8:110}, N3/edi, 4

#() [105->110] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_4"}

#() [265->270] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 15:185}) [185->190] (level:0) is green with stack state #f
#({basic-block #() 190 195}, {basic-block #({tag 16:195}) 195 200})
  bne	{tag 16:195}, N3/edi, 4

#() [190->195] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_4"}

#() [270->275] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

#({tag 8:110}) [110->115] (level:0) is green with stack state #f
#({basic-block #() 115 120}, {basic-block #({tag 9:120}) 120 125})
  bne	{tag 9:120}, N3/edi, 5

#() [115->120] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_5"}

#() [275->280] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 16:195}) [195->200] (level:0) is green with stack state #f
#({basic-block #() 200 205}, {basic-block #({tag 17:205}) 205 210})
  bne	{tag 17:205}, N3/edi, 5

#() [200->205] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_5"}

#() [280->285] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

#({tag 9:120}) [120->125] (level:0) is green with stack state #f
#({basic-block #() 125 130}, {basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  bne	{tag 10:130}, N3/edi, 6

#() [125->130] (level:0) is green with stack state #f
#({basic-block #({tag 3:130}, {tag 10:130}) 130 135})
  move	N2/ebx, {constant "new_gf_xep_6"}

#() [285->290] (level:0) is #f with stack state #f
#()
  bra	{tag 3:130}

#({tag 17:205}) [205->210] (level:0) is green with stack state #f
#({basic-block #() 210 215}, {basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  bne	{tag 18:215}, N3/edi, 6

#() [210->215] (level:0) is green with stack state #f
#({basic-block #({tag 11:215}, {tag 18:215}) 215 220})
  move	N2/ebx, {constant "new_gf_optional_xep_6"}

#() [290->295] (level:0) is #f with stack state #f
#()
  bra	{tag 11:215}

+++ ending code for primitive_set_generic_function_entrypoints +++

+++ No Source Code Locators for primitive_set_generic_function_entrypoints +++


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

+++ Exported function definition primitive_preboot_symbols +++

+++ starting code for primitive_preboot_symbols +++

#() [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 8:145}) 145 160})
  add	N4/ebx, {indirect-constant "Poblist"}, 8
  sub	N5/edi, {indirect-constant "PoblistUcursor"}, 8
  asr	N5/edi, N5/edi, 2
  bne	{tag 8:145}, N5/edi, 0

#() [25->30] (level:0) is green with stack state before
#({basic-block #({tag 1:80}) 80 100})
  move	G6/eax, {constant "KPempty_vectorVKi"}

#({tag 1:80}) [80->100] (level:0) is green with stack state before
#({basic-block #({tag 6:100}) 100 105})
  move	{indirect-constant "PoblistUsize"}, 8
  move	{indirect-constant "PoblistUcursor"}, 8
  move	{indirect-constant "Poblist"}, 0
  move	eax, G6/eax

#({tag 6:100}) [100->105] (level:0) is green with stack state #f
#()
  rts-and-drop	0

#({tag 8:145}) [145->160] (level:0) is #f with stack state #f
#({basic-block #({tag 3:105}) 105 115})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#({tag 3:105}) [105->115] (level:0) is brown with stack state with
#({basic-block #({tag 2:30}) 30 70})
  move	N0/edx, N4/ebx
  move	N1/edi, N5/edi

#({tag 2:30}) [30->70] (level:0) is red with stack state with
#({basic-block #() 70 80})
  asl	N3/ebx, N1/edi, 2
  add	N3/ebx, N3/ebx, 8
  push	N0/edx
  push	1
  push	N1/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N3/ebx
  call-alien	{constant "primitive_alloc_rt"}, 0

#() [70->80] (level:0) is red with stack state with
#({basic-block #({tag 4:120}) 115 120})
  add	esp, esp, 20
  move	G2/eax, eax

#({tag 4:120}) [115->120] (level:0) is yellow with stack state with
#({basic-block #({tag 4:120}, {tag 5:120}) 120 140})
  move	G6/eax, G2/eax

#({tag 4:120}, {tag 5:120}) [120->140] (level:0) is green with stack state with
#({basic-block #({tag 7:140}) 140 145})
  move	{indirect-constant "PoblistUsize"}, 8
  move	{indirect-constant "PoblistUcursor"}, 8
  move	{indirect-constant "Poblist"}, 0
  move	eax, G6/eax

#({tag 7:140}) [140->145] (level:0) is #f with stack state #f
#({basic-block #({tag 6:100}) 100 105})
  preserve-registers-exit	

#() [160->165] (level:0) is #f with stack state #f
#()
  bra	{tag 6:100}

+++ ending code for primitive_preboot_symbols +++

+++ Live variable scopes for primitive_preboot_symbols +++
Start scope at 65 with frame for no variables
End scope at 123

+++ No Source Code Locators for primitive_preboot_symbols +++


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

+++ Exported function definition primitive_make_symbol +++

+++ starting code for primitive_make_symbol +++

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

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

#() [5->30] (level:0) is red with stack state with
#({basic-block #() 30 40})
  move	G0/eax, eax
  push	G0/eax
  push	{constant "KLsymbolGVKdW"}
  push	8
  call-alien	{constant "primitive_alloc_s1"}, 0

#() [30->40] (level:0) is red with stack state with
#({basic-block #({tag 1:45}) 45 50})
  add	esp, esp, 12
  move	eax, eax

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

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

+++ ending code for primitive_make_symbol +++

+++ Live variable scopes for primitive_make_symbol +++
Start scope at 3 with frame for no variables
End scope at 19

+++ No Source Code Locators for primitive_make_symbol +++


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

+++ Exported function definition primitive_string_as_symbol +++

+++ starting code for primitive_string_as_symbol +++

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

#({tag 12:310}) [310->325] (level:0) is #f with stack state #f
#({basic-block #() 5 25})
  preserve-registers-entry	
  allocate-local-area	
  allocate-raw-area	

#() [5->25] (level:0) is green with stack state with
#({basic-block #({tag 3:25}) 25 30})
  move	G18/GSPILL-0, eax
  move	N3/NSPILL-1, {indirect-constant "PoblistUcursor"}
  move	N4/NSPILL-0, {indirect-constant "Poblist"}
  move	N5/ecx, 8

#({tag 3:25}) [25->30] (level:1) is green with stack state with
#({basic-block #() 30 55}, {basic-block #({tag 2:120}) 120 125})
  bge	{tag 2:120}, N5/ecx, N3/NSPILL-1

#() [30->55] (level:1) is green with stack state with
#({basic-block #() 55 65}, {basic-block #({tag 5:115}) 115 120})
  ld	G19/eax, N4/NSPILL-0, N5/ecx
  ld	G2/GSPILL-1, G19/eax, 4
  ld	N7/edi, G18/GSPILL-0, 4
  ld	N8/ebx, G2/GSPILL-1, 4
  bne	{tag 5:115}, N7/edi, N8/ebx

#() [55->65] (level:1) is green with stack state with
#({basic-block #({tag 7:65}) 65 70})
  asr	N6/edi, N7/edi, 2
  sub	N6/edi, N6/edi, 1

#({tag 7:65}) [65->70] (level:2) is green with stack state with
#({basic-block #() 70 85}, {basic-block #({tag 4:125}) 125 130})
  blt	{tag 4:125}, N6/edi, 0

#() [70->85] (level:2) is green with stack state with
#({basic-block #() 85 95}, {basic-block #({tag 6:110}) 110 115})
  ldb-index	N9/edx, G18/GSPILL-0, N6/edi, 8
  ldb-index	N10/ebx, G2/GSPILL-1, N6/edi, 8
  beq	{tag 6:110}, N9/edx, N10/ebx

#() [85->95] (level:2) is green with stack state with
#({basic-block #() 95 105}, {basic-block #({tag 5:115}) 115 120})
  eor	N9/edx, N9/edx, N10/ebx
  bne	{tag 5:115}, N9/edx, 32

#() [95->105] (level:2) is green with stack state with
#({basic-block #() 105 110}, {basic-block #({tag 5:115}) 115 120})
  or	N10/ebx, N10/ebx, 32
  blt	{tag 5:115}, N10/ebx, 97

#() [105->110] (level:2) is green with stack state with
#({basic-block #({tag 6:110}) 110 115}, {basic-block #({tag 5:115}) 115 120})
  bgt	{tag 5:115}, N10/ebx, 122

#({tag 6:110}) [110->115] (level:1) is green with stack state with
#({basic-block #({tag 7:65}) 65 70})
  sub	N6/edi, N6/edi, 1

#() [325->330] (level:0) is #f with stack state #f
#()
  bra	{tag 7:65}

#({tag 2:120}) [120->125] (level:1) is green with stack state with
#({basic-block #({tag 4:125}) 125 130})
  move	G19/eax, {constant "KPfalseVKi"}

#({tag 4:125}) [125->130] (level:2) is green with stack state with
#({basic-block #({tag 9:295}) 295 300}, {basic-block #({tag 1:305}) 285 290})
  bne	{tag 1:305}, G19/eax, {constant "KPfalseVKi"}

#({tag 9:295}) [295->300] (level:2) is brown with stack state with
#({basic-block #() 130 150})
  move	G0/edi, G18/GSPILL-0

#() [130->150] (level:2) is red with stack state with
#({basic-block #() 150 180})
  push	G0/edi
  push	{constant "KLsymbolGVKdW"}
  push	8
  call-alien	{constant "primitive_alloc_s1"}, 0

#() [150->180] (level:2) is red with stack state with
#({basic-block #() 180 235}, {basic-block #({tag 8:270}) 270 285})
  add	esp, esp, 12
  move	G1/GSPILL-0, eax
  move	N12/edi, {indirect-constant "PoblistUsize"}
  move	N15/NSPILL-0, {indirect-constant "PoblistUcursor"}
  move	G11/ebx, {indirect-constant "Poblist"}
  blt	{tag 8:270}, N15/NSPILL-0, N12/edi

#() [180->235] (level:2) is red with stack state with
#({basic-block #() 235 270})
  sub	N13/NSPILL-1, N12/edi, 8
  add	N12/edi, N12/edi, 1024
  add	N17/NSPILL-2, G11/ebx, 8
  sub	N14/ebx, N12/edi, 8
  asr	N14/ebx, N14/ebx, 2
  push	{constant "KPunboundVKi"}
  push	1
  push	N14/ebx
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N12/edi
  call-alien	{constant "primitive_alloc_rf"}, 0

#() [235->270] (level:2) is red with stack state with
#({basic-block #({tag 8:270}) 270 285})
  add	esp, esp, 20
  move	{indirect-constant "Poblist"}, eax
  move	G11/ebx, eax
  add	N16/eax, eax, 8
  move	{indirect-constant "PoblistUsize"}, N12/edi
  asr	N13/NSPILL-1, N13/NSPILL-1, 2
  copy-words-down-w	N16/eax, N17/NSPILL-2, N13/NSPILL-1

#({tag 8:270}) [270->285] (level:2) is red with stack state with
#({basic-block #({tag 10:300}) 300 305})
  st	G1/GSPILL-0, G11/ebx, N15/NSPILL-0
  add	N15/NSPILL-0, N15/NSPILL-0, 4
  move	{indirect-constant "PoblistUcursor"}, N15/NSPILL-0

#({tag 10:300}) [300->305] (level:2) is yellow with stack state with
#({basic-block #({tag 1:305}) 285 290})
  move	G19/eax, G1/GSPILL-0

#({tag 1:305}) [285->290] (level:2) is green with stack state with
#({basic-block #({tag 1:305}, {tag 11:305}) 305 310})
  move	eax, G19/eax

#({tag 1:305}, {tag 11:305}) [305->310] (level:0) is #f with stack state #f
#({basic-block #() 290 295})
  preserve-registers-exit	

#() [290->295] (level:2) is green with stack state #f
#()
  rts-and-drop	0

#({tag 5:115}) [115->120] (level:2) is green with stack state with
#({basic-block #({tag 3:25}) 25 30})
  add	N5/ecx, N5/ecx, 4

#() [330->335] (level:0) is #f with stack state #f
#()
  bra	{tag 3:25}

+++ ending code for primitive_string_as_symbol +++

+++ Frame sizes for primitive_string_as_symbol: GC: 2, NC: 3 +++

+++ Live variable scopes for primitive_string_as_symbol +++
Start scope at 3 with frame for no variables
End scope at 309

+++ No Source Code Locators for primitive_string_as_symbol +++


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

+++ Exported function definition primitive_resolve_symbol +++

+++ starting code for primitive_resolve_symbol +++

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

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

#() [5->30] (level:0) is green with stack state with
#({basic-block #({tag 3:30}) 30 35})
  move	G19/eax, eax
  ld	G0/GSPILL-1, G19/eax, 4
  move	N4/NSPILL-2, {indirect-constant "PoblistUcursor"}
  move	N5/NSPILL-1, {indirect-constant "Poblist"}
  move	N6/NSPILL-0, 8

#({tag 3:30}) [30->35] (level:1) is green with stack state with
#({basic-block #() 35 60}, {basic-block #({tag 2:125}) 125 130})
  bge	{tag 2:125}, N6/NSPILL-0, N4/NSPILL-2

#() [35->60] (level:1) is green with stack state with
#({basic-block #() 60 70}, {basic-block #({tag 5:120}) 120 125})
  ld	G2/ecx, N5/NSPILL-1, N6/NSPILL-0
  ld	G3/GSPILL-0, G2/ecx, 4
  ld	N8/edi, G0/GSPILL-1, 4
  ld	N9/ebx, G3/GSPILL-0, 4
  bne	{tag 5:120}, N8/edi, N9/ebx

#() [60->70] (level:1) is green with stack state with
#({basic-block #({tag 7:70}) 70 75})
  asr	N7/edi, N8/edi, 2
  sub	N7/edi, N7/edi, 1

#({tag 7:70}) [70->75] (level:2) is green with stack state with
#({basic-block #() 75 90}, {basic-block #({tag 4:130}) 130 135})
  blt	{tag 4:130}, N7/edi, 0

#() [75->90] (level:2) is green with stack state with
#({basic-block #() 90 100}, {basic-block #({tag 6:115}) 115 120})
  ldb-index	N10/edx, G0/GSPILL-1, N7/edi, 8
  ldb-index	N11/ebx, G3/GSPILL-0, N7/edi, 8
  beq	{tag 6:115}, N10/edx, N11/ebx

#() [90->100] (level:2) is green with stack state with
#({basic-block #() 100 110}, {basic-block #({tag 5:120}) 120 125})
  eor	N10/edx, N10/edx, N11/ebx
  bne	{tag 5:120}, N10/edx, 32

#() [100->110] (level:2) is green with stack state with
#({basic-block #() 110 115}, {basic-block #({tag 5:120}) 120 125})
  or	N11/ebx, N11/ebx, 32
  blt	{tag 5:120}, N11/ebx, 97

#() [110->115] (level:2) is green with stack state with
#({basic-block #({tag 6:115}) 115 120}, {basic-block #({tag 5:120}) 120 125})
  bgt	{tag 5:120}, N11/ebx, 122

#({tag 6:115}) [115->120] (level:1) is green with stack state with
#({basic-block #({tag 7:70}) 70 75})
  sub	N7/edi, N7/edi, 1

#() [330->335] (level:0) is #f with stack state #f
#()
  bra	{tag 7:70}

#({tag 2:125}) [125->130] (level:1) is green with stack state with
#({basic-block #({tag 4:130}) 130 135})
  move	G2/ecx, {constant "KPfalseVKi"}

#({tag 4:130}) [130->135] (level:2) is green with stack state with
#({basic-block #() 135 155}, {basic-block #({tag 1:265}) 265 270})
  bne	{tag 1:265}, G2/ecx, {constant "KPfalseVKi"}

#() [135->155] (level:2) is green with stack state with
#({basic-block #({tag 9:275}) 275 295}, {basic-block #({tag 8:245}) 245 265})
  move	N21/edx, {indirect-constant "PoblistUsize"}
  move	N22/edi, {indirect-constant "PoblistUcursor"}
  move	G20/ebx, {indirect-constant "Poblist"}
  blt	{tag 8:245}, N22/edi, N21/edx

#({tag 9:275}) [275->295] (level:2) is brown with stack state with
#({basic-block #() 155 210})
  move	G1/GSPILL-0, G19/eax
  move	G12/ebx, G20/ebx
  move	N13/NSPILL-0, N21/edx
  move	N16/NSPILL-3, N22/edi

#() [155->210] (level:2) is red with stack state with
#({basic-block #() 210 245})
  sub	N14/NSPILL-1, N13/NSPILL-0, 8
  add	N13/NSPILL-0, N13/NSPILL-0, 1024
  add	N18/NSPILL-2, G12/ebx, 8
  sub	N15/edi, N13/NSPILL-0, 8
  asr	N15/edi, N15/edi, 2
  push	{constant "KPunboundVKi"}
  push	1
  push	N15/edi
  push	{constant "KLsimple_object_vectorGVKdW"}
  push	N13/NSPILL-0
  call-alien	{constant "primitive_alloc_rf"}, 0

#() [210->245] (level:2) is red with stack state with
#({basic-block #({tag 10:295}) 295 310})
  add	esp, esp, 20
  move	{indirect-constant "Poblist"}, eax
  move	G12/ebx, eax
  add	N17/edi, eax, 8
  move	{indirect-constant "PoblistUsize"}, N13/NSPILL-0
  asr	N14/NSPILL-1, N14/NSPILL-1, 2
  copy-words-down-w	N17/edi, N18/NSPILL-2, N14/NSPILL-1

#({tag 10:295}) [295->310] (level:2) is yellow with stack state with
#({basic-block #({tag 8:245}) 245 265})
  move	G19/eax, G1/GSPILL-0
  move	G20/ebx, G12/ebx
  move	N22/edi, N16/NSPILL-3

#({tag 8:245}) [245->265] (level:2) is green with stack state with
#({basic-block #({tag 1:265}) 265 270})
  st	G19/eax, G20/ebx, N22/edi
  add	N22/edi, N22/edi, 4
  move	{indirect-constant "PoblistUcursor"}, N22/edi
  move	G2/ecx, G19/eax

#({tag 1:265}) [265->270] (level:2) is green with stack state with
#({basic-block #({tag 11:310}) 310 315})
  move	eax, G2/ecx

#({tag 11:310}) [310->315] (level:0) is #f with stack state #f
#({basic-block #() 270 275})
  preserve-registers-exit	

#() [270->275] (level:2) is green with stack state #f
#()
  rts-and-drop	0

#({tag 5:120}) [120->125] (level:2) is green with stack state with
#({basic-block #({tag 3:30}) 30 35})
  add	N6/NSPILL-0, N6/NSPILL-0, 4

#() [335->340] (level:0) is #f with stack state #f
#()
  bra	{tag 3:30}

+++ ending code for primitive_resolve_symbol +++

+++ Frame sizes for primitive_resolve_symbol: GC: 2, NC: 4 +++

+++ Live variable scopes for primitive_resolve_symbol +++
Start scope at 3 with frame for no variables
End scope at 305

+++ No Source Code Locators for primitive_resolve_symbol +++


+++ Exported function definition dylan_stack_overflow_handler +++

+++ starting code for dylan_stack_overflow_handler +++

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

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

#() [5->25] (level:0) is red with stack state with
#({basic-block #() 25 30}, {basic-block #({tag 1:45}) 45 50})
  rem	"eliminated"
  rem	"eliminated"
  rem	"eliminated"
  load-nlx-address	{tag 1:45}, eax

#() [25->30] (level:0) is red with stack state with
#({basic-block #() 30 35})
  call	{constant "primitive_build_unwind_protect_frame"}, 1

#() [30->35] (level:0) is red with stack state with
#({basic-block #() 35 40})
  call	{constant "Kstack_overflow_errorVKiI"}, 0

#() [35->40] (level:0) is red with stack state with
#({basic-block #() 40 45})
  call	{constant "primitive_unwind_protect_cleanup"}, 1

#() [40->45] (level:0) is red with stack state with
#({basic-block #({tag 2:55}) 50 50}, {basic-block #({tag 1:45}) 45 50})
  control-flow-link	{tag 1:45}

#({tag 2:55}) [50->50] (level:0) is red with stack state with
#({basic-block #({tag 2:55}, {tag 3:55}) 55 60})

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

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

#({tag 1:45}) [45->50] (level:1) is red with stack state with
#({basic-block #() 50 50}, {basic-block #({tag 1:45}) 45 50})
  end-cleanup	{tag 1:45}, #[]

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

+++ ending code for dylan_stack_overflow_handler +++

+++ Live variable scopes for dylan_stack_overflow_handler +++
Start scope at 7 with frame for no variables
End scope at 26

+++ No Source Code Locators for dylan_stack_overflow_handler +++


+++ Exported function definition dylan_integer_overflow_handler +++

+++ starting code for dylan_integer_overflow_handler +++

#() [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	{constant "Kmachine_word_overflowVKmI"}, 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 dylan_integer_overflow_handler +++

+++ Live variable scopes for dylan_integer_overflow_handler +++
Start scope at 7 with frame for no variables
End scope at 11

+++ No Source Code Locators for dylan_integer_overflow_handler +++


+++ Exported function definition dylan_integer_divide_0_handler +++

+++ starting code for dylan_integer_divide_0_handler +++

#() [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	{constant "Kinteger_divide_by_0VKeI"}, 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 dylan_integer_divide_0_handler +++

+++ Live variable scopes for dylan_integer_divide_0_handler +++
Start scope at 7 with frame for no variables
End scope at 11

+++ No Source Code Locators for dylan_integer_divide_0_handler +++


+++ Exported function definition dylan_float_divide_0_handler +++

+++ starting code for dylan_float_divide_0_handler +++

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

#({tag 2:25}) [25->40] (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 15})
  clear-float-exceptions	
  call	{constant "Kfloat_divide_by_0VKeI"}, 0

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

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

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

+++ ending code for dylan_float_divide_0_handler +++

+++ Live variable scopes for dylan_float_divide_0_handler +++
Start scope at 7 with frame for no variables
End scope at 13

+++ No Source Code Locators for dylan_float_divide_0_handler +++


+++ Exported function definition dylan_float_overflow_handler +++

+++ starting code for dylan_float_overflow_handler +++

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

#({tag 2:25}) [25->40] (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 15})
  clear-float-exceptions	
  call	{constant "Kfloat_overflowVKeI"}, 0

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

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

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

+++ ending code for dylan_float_overflow_handler +++

+++ Live variable scopes for dylan_float_overflow_handler +++
Start scope at 7 with frame for no variables
End scope at 13

+++ No Source Code Locators for dylan_float_overflow_handler +++


+++ Exported function definition dylan_float_underflow_handler +++

+++ starting code for dylan_float_underflow_handler +++

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

#({tag 2:25}) [25->40] (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 15})
  clear-float-exceptions	
  call	{constant "Kfloat_underflowVKeI"}, 0

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

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

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

+++ ending code for dylan_float_underflow_handler +++

+++ Live variable scopes for dylan_float_underflow_handler +++
Start scope at 7 with frame for no variables
End scope at 13

+++ No Source Code Locators for dylan_float_underflow_handler +++


+++ Exported function definition primitive_float_class +++

+++ starting code for primitive_float_class +++

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

#() [5->15] (level:0) is green with stack state #f
#({basic-block #({tag 1:15}) 15 25})
  classify-float	N1/ebx, ST
  move	N0/eax, 0

#({tag 1:15}) [15->25] (level:1) is green with stack state #f
#({basic-block #() 25 30}, {basic-block #({tag 2:30}) 30 40})
  ld	N2/edi, {constant "Kfloating_point_classes"}, N0/eax
  beq	{tag 2:30}, N1/ebx, N2/edi

#() [25->30] (level:1) is green with stack state #f
#({basic-block #({tag 1:15}) 15 25})
  add	N0/eax, N0/eax, 8

#() [45->50] (level:0) is #f with stack state #f
#()
  bra	{tag 1:15}

#({tag 2:30}) [30->40] (level:1) is green with stack state #f
#({basic-block #() 40 45})
  add	N0/eax, N0/eax, 4
  ld	eax, {constant "Kfloating_point_classes"}, N0/eax

#() [40->45] (level:1) is green with stack state #f
#()
  rts-and-drop	0

+++ ending code for primitive_float_class +++

+++ No Source Code Locators for primitive_float_class +++


+++ starting code for dylan_thread_trampoline +++

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

#({tag 23:585}) [585->600] (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 60})
  load-stack-arg-n	#t, N0/NSPILL--1, 0
  push	336
  call-alien	{constant "dylan__malloc__misc"}, 0

#() [20->60] (level:0) is red with stack state with
#({basic-block #() 60 65})
  add	esp, esp, 4
  move	N6/edi, eax
  add	N7/NSPILL-0, N6/edi, 12
  add	N8/edx, N7/NSPILL-0, 324
  push	N8/edx
  push	N6/edi
  push	N6/edi
  call-alien	{constant "MMRegisterRootAmbig"}, 0

#() [60->65] (level:0) is red with stack state with
#({basic-block #({tag 16:515}) 515 520})
  add	esp, esp, 12

#({tag 16:515}) [515->520] (level:1) is green with stack state with
#({basic-block #({tag 17:70}) 70 75}, {basic-block #({tag 16:515}) 515 520})
  conditional-move	{tag 16:515}, {indirect-constant "Pruntime_spin_lock"}, 1, 0

#({tag 17:70}) [70->75] (level:0) is red with stack state with
#({basic-block #() 75 80}, {basic-block #({tag 1:80}) 80 150})
  beq	{tag 1:80}, {indirect-constant "Pteb_chain"}, 0

#() [75->80] (level:0) is red with stack state with
#({basic-block #({tag 1:80}) 80 150})
  st	N6/edi, {indirect-constant "Pteb_chain"}, 8

#({tag 1:80}) [80->150] (level:0) is red with stack state with
#({basic-block #() 150 175})
  st	{indirect-constant "Pteb_chain"}, N6/edi, 4
  st	0, N6/edi, 8
  move	{indirect-constant "Pteb_chain"}, N6/edi
  move	{indirect-constant "Pruntime_spin_lock"}, 0
  add	N3/edi, N7/NSPILL-0, 32
  st	0, N7/NSPILL-0, 0
  st	0, N7/NSPILL-0, 4
  st	0, N3/edi, 0
  st	{constant "KPempty_listVKi"}, N3/edi, 16
  st	{constant "KPunboundVKi"}, N3/edi, 4
  set-teb	N3/edi
  push	N3/edi
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [150->175] (level:0) is red with stack state with
#({basic-block #() 175 200})
  add	esp, esp, 8
  st	0, N3/edi, 20
  st	-1, N3/edi, 20
  sub	N5/edi, N3/edi, 32
  call-alien	{constant "getpagesize"}, 0

#() [175->200] (level:0) is red with stack state with
#({basic-block #() 200 210})
  sub	N9/eax, eax, 1
  or	N9/eax, N9/eax, esp
  add	N9/eax, N9/eax, 1
  push	N9/eax
  call-alien	{constant "dylan_mm_register_thread"}, 0

#() [200->210] (level:0) is red with stack state with
#({basic-block #() 210 225}, {basic-block #({tag 14:500}) 500 515})
  add	esp, esp, 4
  beq	{tag 14:500}, eax, 0

#() [210->225] (level:0) is red with stack state with
#({basic-block #() 225 235})
  push	0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [225->235] (level:0) is red with stack state with
#({basic-block #({tag 14:500}) 500 515})
  add	esp, esp, 8
  halt	

#({tag 14:500}) [500->515] (level:1) is green with stack state with
#({basic-block #({tag 15:250}) 250 285}, {basic-block #({tag 14:500}) 500 515})
  move	N10/eax, {indirect-constant "Pruntime_thread_count"}
  add	N11/edx, N10/eax, 1
  conditional-move	{tag 14:500}, {indirect-constant "Pruntime_thread_count"}, N11/edx, N10/eax

#({tag 15:250}) [250->285] (level:0) is red with stack state with
#({basic-block #() 285 315})
  init-fpu	
  push	0
  move	N2/NSPILL-0, esp
  ld	G1/GSPILL-0, N0/NSPILL--1, 0
  push	4
  push	N0/NSPILL--1
  call-alien	{constant "dylan__free__root"}, 0

#() [285->315] (level:0) is red with stack state with
#({basic-block #() 315 330})
  add	esp, esp, 8
  push	0
  push	G1/GSPILL-0
  push	{constant "trampoline_body"}
  push	N2/NSPILL-0
  call-alien	{constant "dylan_init_thread"}, 0

#() [315->330] (level:0) is red with stack state with
#({basic-block #() 330 340})
  add	esp, esp, 16
  push	N5/edi
  call-alien	{constant "dylan_mm_deregister_thread_from_teb"}, 0

#() [330->340] (level:0) is red with stack state with
#({basic-block #({tag 12:485}) 485 500})
  add	esp, esp, 4
  st	0, N5/edi, 4

#({tag 12:485}) [485->500] (level:1) is green with stack state with
#({basic-block #({tag 13:355}) 355 370}, {basic-block #({tag 12:485}) 485 500})
  move	N12/eax, {indirect-constant "Pruntime_thread_count"}
  sub	N13/edx, N12/eax, 1
  conditional-move	{tag 12:485}, {indirect-constant "Pruntime_thread_count"}, N13/edx, N12/eax

#({tag 13:355}) [355->370] (level:0) is red with stack state with
#({basic-block #() 370 380})
  push	0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [370->380] (level:0) is red with stack state with
#({basic-block #({tag 10:480}) 480 485})
  add	esp, esp, 8
  sub	N14/edx, N5/edi, 12

#({tag 10:480}) [480->485] (level:1) is green with stack state with
#({basic-block #({tag 11:385}) 385 400}, {basic-block #({tag 10:480}) 480 485})
  conditional-move	{tag 10:480}, {indirect-constant "Pruntime_spin_lock"}, 1, 0

#({tag 11:385}) [385->400] (level:0) is red with stack state with
#({basic-block #() 400 405}, {basic-block #({tag 6:405}) 405 410})
  ld	N15/eax, N14/edx, 4
  ld	N16/ebx, N14/edx, 8
  bne	{tag 6:405}, {indirect-constant "Pteb_chain"}, N14/edx

#() [400->405] (level:0) is red with stack state with
#({basic-block #({tag 7:410}) 410 415})
  move	{indirect-constant "Pteb_chain"}, N15/eax

#({tag 7:410}) [410->415] (level:0) is red with stack state with
#({basic-block #() 415 420}, {basic-block #({tag 8:420}) 420 440})
  beq	{tag 8:420}, N15/eax, 0

#() [415->420] (level:0) is red with stack state with
#({basic-block #({tag 8:420}) 420 440})
  st	N16/ebx, N15/eax, 8

#({tag 8:420}) [420->440] (level:0) is red with stack state with
#({basic-block #() 440 465})
  move	{indirect-constant "Pruntime_spin_lock"}, 0
  ld	N14/edx, N5/edi, -12
  push	N14/edx
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [440->465] (level:0) is red with stack state with
#({basic-block #() 465 475})
  add	esp, esp, 4
  sub	N14/edx, N5/edi, 12
  push	336
  push	N14/edx
  call-alien	{constant "MMFreeMisc"}, 0

#() [465->475] (level:0) is red with stack state with
#({basic-block #({tag 18:520}) 520 525})
  add	esp, esp, 8
  move	eax, 0

#({tag 18:520}) [520->525] (level:0) is #f with stack state #f
#({basic-block #() 475 480})
  preserve-registers-exit	

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

#({tag 6:405}) [405->410] (level:0) is red with stack state with
#({basic-block #({tag 7:410}) 410 415})
  st	N15/eax, N16/ebx, 4

#() [600->605] (level:0) is #f with stack state #f
#()
  bra	{tag 7:410}

+++ ending code for dylan_thread_trampoline +++

+++ Frame sizes for dylan_thread_trampoline: GC: 1, NC: 1 +++

+++ Live variable scopes for dylan_thread_trampoline +++
Start scope at 6 with frame for no variables
End scope at 481

+++ No Source Code Locators for dylan_thread_trampoline +++


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

+++ starting code for DylanSOEntry +++

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

#({tag 9:210}) [210->225] (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 60})
  call-alien	{constant "tlv_create_key"}, 0

#() [10->60] (level:0) is red with stack state with
#({basic-block #() 60 75})
  move	{indirect-constant "Pteb_tlv_index"}, eax
  st	0, {constant "Pmaster_gc_teb"}, 0
  st	0, {constant "Pmaster_gc_teb"}, 4
  st	0, {constant "Pmaster_teb"}, 0
  st	{constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16
  st	{constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4
  set-teb	{constant "Pmaster_teb"}
  push	{constant "Pmaster_teb"}
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [60->75] (level:0) is red with stack state with
#({basic-block #() 75 80})
  add	esp, esp, 8
  st	0, {constant "Pmaster_teb"}, 20
  call-alien	{constant "dylan_init_memory_manager"}, 0

#() [75->80] (level:0) is red with stack state with
#({basic-block #() 80 105})
  call-alien	{constant "getpagesize"}, 0

#() [80->105] (level:0) is red with stack state with
#({basic-block #() 105 115})
  sub	N0/eax, eax, 1
  or	N0/eax, N0/eax, esp
  add	N0/eax, N0/eax, 1
  push	N0/eax
  call-alien	{constant "dylan_mm_register_thread"}, 0

#() [105->115] (level:0) is red with stack state with
#({basic-block #() 115 130}, {basic-block #({tag 5:175}) 175 175})
  add	esp, esp, 4
  beq	{tag 5:175}, eax, 0

#() [115->130] (level:0) is red with stack state with
#({basic-block #() 130 140})
  push	0
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_set_value"}, 0

#() [130->140] (level:0) is red with stack state with
#({basic-block #({tag 5:175}) 175 175})
  add	esp, esp, 8
  halt	

#({tag 5:175}) [175->175] (level:0) is yellow with stack state with
#({basic-block #({tag 5:175}, {tag 6:175}) 175 190})

#({tag 5:175}, {tag 6:175}) [175->190] (level:1) is green with stack state with
#({basic-block #({tag 4:155}) 175 175}, {basic-block #({tag 5:175}, {tag 6:175}) 175 190})
  move	N1/eax, {indirect-constant "Pruntime_thread_count"}
  add	N2/edx, N1/eax, 1
  conditional-move	{tag 6:175}, {indirect-constant "Pruntime_thread_count"}, N2/edx, N1/eax

#({tag 4:155}) [175->175] (level:0) is brown with stack state with
#({basic-block #({tag 4:155}) 155 165})

#({tag 4:155}) [155->165] (level:0) is red with stack state with
#({basic-block #() 165 170})
  init-fpu	
  call-alien	{constant "dylan_initialize"}, 0

#() [165->170] (level:0) is red with stack state with
#({basic-block #({tag 7:190}) 190 195})
  move	eax, 0

#({tag 7:190}) [190->195] (level:0) is #f with stack state #f
#({basic-block #() 170 175})
  preserve-registers-exit	

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

+++ ending code for DylanSOEntry +++

+++ Live variable scopes for DylanSOEntry +++
Start scope at 4 with frame for no variables
End scope at 199

+++ No Source Code Locators for DylanSOEntry +++


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

+++ starting code for DylanSOExit +++

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

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

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

#() [25->35] (level:0) is red with stack state with
#({basic-block #() 35 45}, {basic-block #({tag 2:70}) 70 75})
  ld	N0/edx, {constant "Pmaster_gc_teb"}, 4
  beq	{tag 2:70}, N0/edx, 0

#() [35->45] (level:0) is red with stack state with
#({basic-block #() 45 55})
  push	{constant "Pmaster_gc_teb"}
  call-alien	{constant "dylan_mm_deregister_thread_from_teb"}, 0

#() [45->55] (level:0) is red with stack state with
#({basic-block #({tag 15:285}) 285 300})
  add	esp, esp, 4
  st	0, {constant "Pmaster_gc_teb"}, 4

#({tag 15:285}) [285->300] (level:1) is green with stack state with
#({basic-block #({tag 2:70}) 70 75}, {basic-block #({tag 15:285}) 285 300})
  move	N1/eax, {indirect-constant "Pruntime_thread_count"}
  sub	N2/edx, N1/eax, 1
  conditional-move	{tag 15:285}, {indirect-constant "Pruntime_thread_count"}, N2/edx, N1/eax

#({tag 2:70}) [70->75] (level:0) is green with stack state with
#({basic-block #({tag 5:75}) 75 80})
  move	N3/NSPILL-0, {indirect-constant "Pteb_chain"}

#({tag 5:75}) [75->80] (level:1) is green with stack state with
#({basic-block #() 80 95}, {basic-block #({tag 4:230}) 230 240})
  beq	{tag 4:230}, N3/NSPILL-0, 0

#() [80->95] (level:1) is green with stack state with
#({basic-block #() 95 105}, {basic-block #({tag 6:130}) 130 140})
  add	N4/edi, N3/NSPILL-0, 12
  ld	N5/edx, N4/edi, 4
  beq	{tag 6:130}, N5/edx, 0

#() [95->105] (level:1) is red with stack state with
#({basic-block #() 105 115})
  push	N4/edi
  call-alien	{constant "dylan_mm_deregister_thread_from_teb"}, 0

#() [105->115] (level:1) is red with stack state with
#({basic-block #({tag 14:270}) 270 285})
  add	esp, esp, 4
  st	0, N4/edi, 4

#({tag 14:270}) [270->285] (level:2) is green with stack state with
#({basic-block #({tag 6:130}) 130 140}, {basic-block #({tag 14:270}) 270 285})
  move	N6/eax, {indirect-constant "Pruntime_thread_count"}
  sub	N7/edx, N6/eax, 1
  conditional-move	{tag 14:270}, {indirect-constant "Pruntime_thread_count"}, N7/edx, N6/eax

#({tag 6:130}) [130->140] (level:1) is green with stack state with
#({basic-block #({tag 12:265}) 265 270})
  ld	N3/NSPILL-0, N3/NSPILL-0, 4
  sub	N8/edx, N4/edi, 12

#({tag 12:265}) [265->270] (level:2) is green with stack state with
#({basic-block #({tag 13:145}) 145 160}, {basic-block #({tag 12:265}) 265 270})
  conditional-move	{tag 12:265}, {indirect-constant "Pruntime_spin_lock"}, 1, 0

#({tag 13:145}) [145->160] (level:1) is red with stack state with
#({basic-block #() 160 165}, {basic-block #({tag 8:165}) 165 170})
  ld	N9/eax, N8/edx, 4
  ld	N10/ebx, N8/edx, 8
  bne	{tag 8:165}, {indirect-constant "Pteb_chain"}, N8/edx

#() [160->165] (level:1) is red with stack state with
#({basic-block #({tag 9:170}) 170 175})
  move	{indirect-constant "Pteb_chain"}, N9/eax

#({tag 9:170}) [170->175] (level:1) is red with stack state with
#({basic-block #() 175 180}, {basic-block #({tag 10:180}) 180 200})
  beq	{tag 10:180}, N9/eax, 0

#() [175->180] (level:1) is red with stack state with
#({basic-block #({tag 10:180}) 180 200})
  st	N10/ebx, N9/eax, 8

#({tag 10:180}) [180->200] (level:1) is red with stack state with
#({basic-block #() 200 225})
  move	{indirect-constant "Pruntime_spin_lock"}, 0
  ld	N8/edx, N4/edi, -12
  push	N8/edx
  call-alien	{constant "MMDeregisterRoot"}, 0

#() [200->225] (level:1) is red with stack state with
#({basic-block #() 225 230})
  add	esp, esp, 4
  sub	N8/edx, N4/edi, 12
  push	336
  push	N8/edx
  call-alien	{constant "MMFreeMisc"}, 0

#() [225->230] (level:1) is red with stack state with
#({basic-block #({tag 5:75}) 75 80})
  add	esp, esp, 8

#() [365->370] (level:0) is #f with stack state #f
#()
  bra	{tag 5:75}

#({tag 4:230}) [230->240] (level:1) is red with stack state with
#({basic-block #() 240 250})
  push	{indirect-constant "Pteb_tlv_index"}
  call-alien	{constant "tlv_destroy_key"}, 0

#() [240->250] (level:1) is red with stack state with
#({basic-block #() 250 255}, {basic-block #({tag 1:255}) 255 260})
  add	esp, esp, 4
  bne	{tag 1:255}, {indirect-constant "Pruntime_thread_count"}, 0

#() [250->255] (level:1) is red with stack state with
#({basic-block #({tag 1:255}) 255 260})
  call-alien	{constant "dylan_shut_down_memory_manager"}, 0

#({tag 1:255}) [255->260] (level:1) is red with stack state with
#({basic-block #({tag 18:330}) 330 335})
  move	eax, 0

#({tag 18:330}) [330->335] (level:0) is #f with stack state #f
#({basic-block #() 260 265})
  preserve-registers-exit	

#() [260->265] (level:1) is red with stack state #f
#()
  rts-and-drop	0

#({tag 8:165}) [165->170] (level:1) is red with stack state with
#({basic-block #({tag 9:170}) 170 175})
  st	N9/eax, N10/ebx, 4

#() [370->375] (level:0) is #f with stack state #f
#()
  bra	{tag 9:170}

+++ ending code for DylanSOExit +++

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

+++ Live variable scopes for DylanSOExit +++
Start scope at 7 with frame for no variables
End scope at 295

+++ No Source Code Locators for DylanSOExit +++

