
.namespace []
.sub "_block1000"  :anon :subid("10_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 0
    .const 'Sub' $P1003 = "11_1781909138.43249" 
    capture_lex $P1003
.annotate 'line', 1
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 6
    .const 'Sub' $P1003 = "11_1781909138.43249" 
    capture_lex $P1003
    $P102 = $P1003()
.annotate 'line', 1
    .return ($P102)
    .const 'Sub' $P1204 = "52_1781909138.43249" 
    .return ($P1204)
.end


.namespace []
.sub "" :load :init :subid("post53") :outer("10_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 0
    .const 'Sub' $P1001 = "10_1781909138.43249" 
    .local pmc block
    set block, $P1001
    $P1206 = get_root_global ["parrot"], "P6metaclass"
    $P1206."new_class"("ProfTest::Want", "Hash" :named("parent"))
.end


.namespace ["ProfTest";"Want"]
.sub "_block1002"  :subid("11_1781909138.43249") :outer("10_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 6
    .const 'Sub' $P1014 = "15_1781909138.43249" 
    capture_lex $P1014
    .const 'Sub' $P1010 = "14_1781909138.43249" 
    capture_lex $P1010
    .const 'Sub' $P1007 = "13_1781909138.43249" 
    capture_lex $P1007
    .const 'Sub' $P1004 = "12_1781909138.43249" 
    capture_lex $P1004
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 15
    .const 'Sub' $P1014 = "15_1781909138.43249" 
    capture_lex $P1014
    $P101 = $P1014()
.annotate 'line', 6
    .return ($P101)
    .const 'Sub' $P1200 = "51_1781909138.43249" 
    .return ($P1200)
.end


.namespace ["ProfTest";"Want"]
.sub "" :load :init :subid("post54") :outer("11_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 6
    .const 'Sub' $P1003 = "11_1781909138.43249" 
    .local pmc block
    set block, $P1003
    $P1202 = get_root_global ["parrot"], "P6metaclass"
    $P1202."new_class"("ProfTest::Want::Goal")
.end


.namespace ["ProfTest";"Want"]
.include "except_types.pasm"
.sub "new"  :subid("12_1781909138.43249") :method :outer("11_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 6
    new $P1006, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1006, control_1005
    push_eh $P1006
    .lex "self", self
    $P100 = "die"("...")
    .return ($P100)
  control_1005:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want"]
.include "except_types.pasm"
.sub "accepts"  :subid("13_1781909138.43249") :method :outer("11_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 8
    new $P1009, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1009, control_1008
    push_eh $P1009
    .lex "self", self
    .return (1)
  control_1008:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want"]
.include "except_types.pasm"
.sub "goal"  :subid("14_1781909138.43249") :method :outer("11_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 10
    new $P1012, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1012, control_1011
    push_eh $P1012
    .lex "self", self
    .return (0)
  control_1011:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Goal"]
.sub "_block1013"  :subid("15_1781909138.43249") :outer("11_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 15
    .const 'Sub' $P1025 = "19_1781909138.43249" 
    capture_lex $P1025
    .const 'Sub' $P1021 = "18_1781909138.43249" 
    capture_lex $P1021
    .const 'Sub' $P1018 = "17_1781909138.43249" 
    capture_lex $P1018
    .const 'Sub' $P1015 = "16_1781909138.43249" 
    capture_lex $P1015
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 25
    .const 'Sub' $P1025 = "19_1781909138.43249" 
    capture_lex $P1025
    $P102 = $P1025()
.annotate 'line', 15
    .return ($P102)
    .const 'Sub' $P1196 = "50_1781909138.43249" 
    .return ($P1196)
.end


.namespace ["ProfTest";"Want";"Goal"]
.sub "" :load :init :subid("post55") :outer("15_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 15
    .const 'Sub' $P1014 = "15_1781909138.43249" 
    .local pmc block
    set block, $P1014
    $P1198 = get_root_global ["parrot"], "P6metaclass"
    $P1198."new_class"("ProfTest::Want::Any", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"Goal"]
.include "except_types.pasm"
.sub "new"  :subid("16_1781909138.43249") :method :outer("15_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 15
    new $P1017, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1017, control_1016
    push_eh $P1017
    .lex "self", self
    find_lex $P100, "self"
    .return ($P100)
  control_1016:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"Goal"]
.include "except_types.pasm"
.sub "goal"  :subid("17_1781909138.43249") :method :outer("15_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 17
    new $P1020, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1020, control_1019
    push_eh $P1020
    .lex "self", self
    .return (1)
  control_1019:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Goal"]
.include "except_types.pasm"
.sub "get_str"  :subid("18_1781909138.43249") :method :outer("15_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 19
    new $P1023, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1023, control_1022
    push_eh $P1023
    .lex "self", self
    .return ("Goal")
  control_1022:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Any"]
.sub "_block1024"  :subid("19_1781909138.43249") :outer("15_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 25
    .const 'Sub' $P1051 = "24_1781909138.43249" 
    capture_lex $P1051
    .const 'Sub' $P1043 = "23_1781909138.43249" 
    capture_lex $P1043
    .const 'Sub' $P1032 = "21_1781909138.43249" 
    capture_lex $P1032
    .const 'Sub' $P1026 = "20_1781909138.43249" 
    capture_lex $P1026
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 52
    .const 'Sub' $P1051 = "24_1781909138.43249" 
    capture_lex $P1051
    $P101 = $P1051()
.annotate 'line', 25
    .return ($P101)
    .const 'Sub' $P1192 = "49_1781909138.43249" 
    .return ($P1192)
.end


.namespace ["ProfTest";"Want";"Any"]
.sub "" :load :init :subid("post56") :outer("19_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 25
    .const 'Sub' $P1025 = "19_1781909138.43249" 
    .local pmc block
    set block, $P1025
    $P1194 = get_root_global ["parrot"], "P6metaclass"
    $P1194."new_class"("ProfTest::Want::Version", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"Any"]
.include "except_types.pasm"
.sub "new"  :subid("20_1781909138.43249") :method :outer("19_1781909138.43249")
    .param pmc param_1029 :optional
    .param int has_param_1029 :opt_flag
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 25
    new $P1028, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1028, control_1027
    push_eh $P1028
    .lex "self", self
    if has_param_1029, optparam_57
    $P1030 = root_new ['parrot';'ResizablePMCArray']
    set param_1029, $P1030
  optparam_57:
    .lex "@except", param_1029
.annotate 'line', 26
    find_lex $P100, "@except"
    find_lex $P1031, "self"
    unless_null $P1031, vivify_58
    $P1031 = root_new ['parrot';'Hash']
    store_lex "self", $P1031
  vivify_58:
    set $P1031["except"], $P100
.annotate 'line', 25
    find_lex $P100, "self"
    .return ($P100)
  control_1027:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"Any"]
.include "except_types.pasm"
.sub "accepts"  :subid("21_1781909138.43249") :method :outer("19_1781909138.43249")
    .param pmc param_1035
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 30
    .const 'Sub' $P1038 = "22_1781909138.43249" 
    capture_lex $P1038
    new $P1034, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1034, control_1033
    push_eh $P1034
    .lex "self", self
    .lex "%prof_line", param_1035
.annotate 'line', 31
    find_lex $P1036, "self"
    unless_null $P1036, vivify_59
    $P1036 = root_new ['parrot';'Hash']
  vivify_59:
    set $P101, $P1036["except"]
    unless_null $P101, vivify_60
    new $P101, "Undef"
  vivify_60:
    defined $I100, $P101
    unless $I100, for_undef_61
    iter $P100, $P101
    new $P104, 'ExceptionHandler', [.CONTROL_LOOP_NEXT;.CONTROL_LOOP_REDO;.CONTROL_LOOP_LAST]
    set_label $P104, loop1042_handler
    push_eh $P104
  loop1042_test:
    unless $P100, loop1042_done
    shift $P102, $P100
  loop1042_redo:
    .const 'Sub' $P1038 = "22_1781909138.43249" 
    capture_lex $P1038
    $P1038($P102)
  loop1042_next:
    goto loop1042_test
  loop1042_handler:
    .local pmc exception 
    .get_results (exception) 
    pop_upto_eh exception
    getattribute $P105, exception, 'type'
    eq $P105, .CONTROL_LOOP_NEXT, loop1042_next
    eq $P105, .CONTROL_LOOP_REDO, loop1042_redo
  loop1042_done:
    pop_eh 
  for_undef_61:
.annotate 'line', 36
    new $P100, "Exception"
    set $P100['type'], .CONTROL_RETURN
    new $P101, "Integer"
    assign $P101, 1
    setattribute $P100, 'payload', $P101
    throw $P100
.annotate 'line', 30
    .return ()
  control_1033:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Any"]
.include "except_types.pasm"
.sub "_block1037"  :anon :subid("22_1781909138.43249") :outer("21_1781909138.43249")
    .param pmc param_1039
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 31
    .lex "$except_type", param_1039
.annotate 'line', 32
    find_lex $P104, "$except_type"
    set $S100, $P104
    find_lex $P1041, "%prof_line"
    unless_null $P1041, vivify_62
    $P1041 = root_new ['parrot';'Hash']
  vivify_62:
    set $P105, $P1041["type"]
    unless_null $P105, vivify_63
    new $P105, "Undef"
  vivify_63:
    set $S101, $P105
    iseq $I101, $S100, $S101
    if $I101, if_1040
    new $P103, 'Integer'
    set $P103, $I101
    goto if_1040_end
  if_1040:
.annotate 'line', 33
    new $P106, "Exception"
    set $P106['type'], .CONTROL_RETURN
    new $P107, "Integer"
    assign $P107, 0
    setattribute $P106, 'payload', $P107
    throw $P106
  if_1040_end:
.annotate 'line', 31
    .return ($P103)
.end


.namespace ["ProfTest";"Want";"Any"]
.include "except_types.pasm"
.sub "get_str"  :subid("23_1781909138.43249") :method :outer("19_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 39
    new $P1045, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1045, control_1044
    push_eh $P1045
    .lex "self", self
.annotate 'line', 40
    new $P100, "Undef"
    set $P1046, $P100
    .lex "$str", $P1046
    new $P101, "String"
    assign $P101, "Any("
    store_lex "$str", $P101
.annotate 'line', 41
    find_lex $P1048, "self"
    unless_null $P1048, vivify_64
    $P1048 = root_new ['parrot';'Hash']
  vivify_64:
    set $P101, $P1048["except"]
    unless_null $P101, vivify_65
    new $P101, "Undef"
  vivify_65:
    unless $P101, if_1047_end
.annotate 'line', 42
    find_lex $P102, "$str"
    concat $P103, $P102, "except("
    find_lex $P1049, "self"
    unless_null $P1049, vivify_66
    $P1049 = root_new ['parrot';'Hash']
  vivify_66:
    set $P104, $P1049["except"]
    unless_null $P104, vivify_67
    new $P104, "Undef"
  vivify_67:
    $S100 = "join"(",", $P104)
    concat $P105, $P103, $S100
    concat $P106, $P105, "),"
    store_lex "$str", $P106
  if_1047_end:
.annotate 'line', 44
    find_lex $P101, "$str"
    concat $P102, $P101, ")"
    store_lex "$str", $P102
.annotate 'line', 39
    find_lex $P101, "$str"
    .return ($P101)
  control_1044:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"Version"]
.sub "_block1050"  :subid("24_1781909138.43249") :outer("19_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 52
    .const 'Sub' $P1071 = "28_1781909138.43249" 
    capture_lex $P1071
    .const 'Sub' $P1063 = "27_1781909138.43249" 
    capture_lex $P1063
    .const 'Sub' $P1057 = "26_1781909138.43249" 
    capture_lex $P1057
    .const 'Sub' $P1052 = "25_1781909138.43249" 
    capture_lex $P1052
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 76
    .const 'Sub' $P1071 = "28_1781909138.43249" 
    capture_lex $P1071
    $P102 = $P1071()
.annotate 'line', 52
    .return ($P102)
    .const 'Sub' $P1188 = "48_1781909138.43249" 
    .return ($P1188)
.end


.namespace ["ProfTest";"Want";"Version"]
.sub "" :load :init :subid("post68") :outer("24_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 52
    .const 'Sub' $P1051 = "24_1781909138.43249" 
    .local pmc block
    set block, $P1051
    $P1190 = get_root_global ["parrot"], "P6metaclass"
    $P1190."new_class"("ProfTest::Want::CLI", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"Version"]
.include "except_types.pasm"
.sub "new"  :subid("25_1781909138.43249") :method :outer("24_1781909138.43249")
    .param pmc param_1055 :optional
    .param int has_param_1055 :opt_flag
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 52
    new $P1054, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1054, control_1053
    push_eh $P1054
    .lex "self", self
    if has_param_1055, optparam_69
    new $P100, "Undef"
    set param_1055, $P100
  optparam_69:
    .lex "$version", param_1055
.annotate 'line', 53
    find_lex $P101, "$version"
    find_lex $P1056, "self"
    unless_null $P1056, vivify_70
    $P1056 = root_new ['parrot';'Hash']
    store_lex "self", $P1056
  vivify_70:
    set $P1056["version"], $P101
.annotate 'line', 52
    find_lex $P101, "self"
    .return ($P101)
  control_1053:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"Version"]
.include "except_types.pasm"
.sub "accepts"  :subid("26_1781909138.43249") :method :outer("24_1781909138.43249")
    .param pmc param_1060
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 57
    new $P1059, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1059, control_1058
    push_eh $P1059
    .lex "self", self
    .lex "%prof_line", param_1060
.annotate 'line', 58
    find_lex $P1062, "%prof_line"
    unless_null $P1062, vivify_71
    $P1062 = root_new ['parrot';'Hash']
  vivify_71:
    set $P101, $P1062["type"]
    unless_null $P101, vivify_72
    new $P101, "Undef"
  vivify_72:
    set $S100, $P101
    iseq $I100, $S100, "VERSION"
    if $I100, if_1061
    new $P100, 'Integer'
    set $P100, $I100
    goto if_1061_end
  if_1061:
.annotate 'line', 59
    new $P102, "Exception"
    set $P102['type'], .CONTROL_RETURN
    new $P103, "Integer"
    assign $P103, 1
    setattribute $P102, 'payload', $P103
    throw $P102
  if_1061_end:
.annotate 'line', 57
    .return ($P100)
  control_1058:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"Version"]
.include "except_types.pasm"
.sub "get_str"  :subid("27_1781909138.43249") :method :outer("24_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 63
    new $P1065, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1065, control_1064
    push_eh $P1065
    .lex "self", self
.annotate 'line', 64
    new $P100, "Undef"
    set $P1066, $P100
    .lex "$str", $P1066
    new $P101, "String"
    assign $P101, "Version("
    store_lex "$str", $P101
.annotate 'line', 65
    find_lex $P1068, "self"
    unless_null $P1068, vivify_73
    $P1068 = root_new ['parrot';'Hash']
  vivify_73:
    set $P101, $P1068["version"]
    unless_null $P101, vivify_74
    new $P101, "Undef"
  vivify_74:
    unless $P101, if_1067_end
.annotate 'line', 66
    find_lex $P102, "$str"
    concat $P103, $P102, "version("
    find_lex $P1069, "self"
    unless_null $P1069, vivify_75
    $P1069 = root_new ['parrot';'Hash']
  vivify_75:
    set $P104, $P1069["version"]
    unless_null $P104, vivify_76
    new $P104, "Undef"
  vivify_76:
    concat $P105, $P103, $P104
    concat $P106, $P105, ")"
    store_lex "$str", $P106
  if_1067_end:
.annotate 'line', 68
    find_lex $P101, "$str"
    concat $P102, $P101, ")"
    store_lex "$str", $P102
.annotate 'line', 63
    find_lex $P101, "$str"
    .return ($P101)
  control_1064:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"CLI"]
.sub "_block1070"  :subid("28_1781909138.43249") :outer("24_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 76
    .const 'Sub' $P1085 = "32_1781909138.43249" 
    capture_lex $P1085
    .const 'Sub' $P1081 = "31_1781909138.43249" 
    capture_lex $P1081
    .const 'Sub' $P1075 = "30_1781909138.43249" 
    capture_lex $P1075
    .const 'Sub' $P1072 = "29_1781909138.43249" 
    capture_lex $P1072
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 90
    .const 'Sub' $P1085 = "32_1781909138.43249" 
    capture_lex $P1085
    $P101 = $P1085()
.annotate 'line', 76
    .return ($P101)
    .const 'Sub' $P1184 = "47_1781909138.43249" 
    .return ($P1184)
.end


.namespace ["ProfTest";"Want";"CLI"]
.sub "" :load :init :subid("post77") :outer("28_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 76
    .const 'Sub' $P1071 = "28_1781909138.43249" 
    .local pmc block
    set block, $P1071
    $P1186 = get_root_global ["parrot"], "P6metaclass"
    $P1186."new_class"("ProfTest::Want::EndOfRunloop", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"CLI"]
.include "except_types.pasm"
.sub "new"  :subid("29_1781909138.43249") :method :outer("28_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 76
    new $P1074, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1074, control_1073
    push_eh $P1074
    .lex "self", self
    find_lex $P100, "self"
    .return ($P100)
  control_1073:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"CLI"]
.include "except_types.pasm"
.sub "accepts"  :subid("30_1781909138.43249") :method :outer("28_1781909138.43249")
    .param pmc param_1078
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 78
    new $P1077, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1077, control_1076
    push_eh $P1077
    .lex "self", self
    .lex "%prof_line", param_1078
.annotate 'line', 79
    find_lex $P1080, "%prof_line"
    unless_null $P1080, vivify_78
    $P1080 = root_new ['parrot';'Hash']
  vivify_78:
    set $P101, $P1080["type"]
    unless_null $P101, vivify_79
    new $P101, "Undef"
  vivify_79:
    set $S100, $P101
    iseq $I100, $S100, "CLI"
    if $I100, if_1079
    new $P100, 'Integer'
    set $P100, $I100
    goto if_1079_end
  if_1079:
.annotate 'line', 80
    new $P102, "Exception"
    set $P102['type'], .CONTROL_RETURN
    new $P103, "Integer"
    assign $P103, 1
    setattribute $P102, 'payload', $P103
    throw $P102
  if_1079_end:
.annotate 'line', 78
    .return ($P100)
  control_1076:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"CLI"]
.include "except_types.pasm"
.sub "get_str"  :subid("31_1781909138.43249") :method :outer("28_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 84
    new $P1083, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1083, control_1082
    push_eh $P1083
    .lex "self", self
    .return ("CLI()")
  control_1082:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.sub "_block1084"  :subid("32_1781909138.43249") :outer("28_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 90
    .const 'Sub' $P1099 = "36_1781909138.43249" 
    capture_lex $P1099
    .const 'Sub' $P1095 = "35_1781909138.43249" 
    capture_lex $P1095
    .const 'Sub' $P1089 = "34_1781909138.43249" 
    capture_lex $P1089
    .const 'Sub' $P1086 = "33_1781909138.43249" 
    capture_lex $P1086
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 104
    .const 'Sub' $P1099 = "36_1781909138.43249" 
    capture_lex $P1099
    $P102 = $P1099()
.annotate 'line', 90
    .return ($P102)
    .const 'Sub' $P1180 = "46_1781909138.43249" 
    .return ($P1180)
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.sub "" :load :init :subid("post80") :outer("32_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 90
    .const 'Sub' $P1085 = "32_1781909138.43249" 
    .local pmc block
    set block, $P1085
    $P1182 = get_root_global ["parrot"], "P6metaclass"
    $P1182."new_class"("ProfTest::Want::Op", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.include "except_types.pasm"
.sub "new"  :subid("33_1781909138.43249") :method :outer("32_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 90
    new $P1088, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1088, control_1087
    push_eh $P1088
    .lex "self", self
    find_lex $P100, "self"
    .return ($P100)
  control_1087:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.include "except_types.pasm"
.sub "accepts"  :subid("34_1781909138.43249") :method :outer("32_1781909138.43249")
    .param pmc param_1092
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 92
    new $P1091, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1091, control_1090
    push_eh $P1091
    .lex "self", self
    .lex "%prof_line", param_1092
.annotate 'line', 93
    find_lex $P1094, "%prof_line"
    unless_null $P1094, vivify_81
    $P1094 = root_new ['parrot';'Hash']
  vivify_81:
    set $P101, $P1094["type"]
    unless_null $P101, vivify_82
    new $P101, "Undef"
  vivify_82:
    set $S100, $P101
    iseq $I100, $S100, "END_OF_RUNLOOP"
    if $I100, if_1093
    new $P100, 'Integer'
    set $P100, $I100
    goto if_1093_end
  if_1093:
.annotate 'line', 94
    new $P102, "Exception"
    set $P102['type'], .CONTROL_RETURN
    new $P103, "Integer"
    assign $P103, 1
    setattribute $P102, 'payload', $P103
    throw $P102
  if_1093_end:
.annotate 'line', 92
    .return ($P100)
  control_1090:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P101, exception, "payload"
    .return ($P101)
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.include "except_types.pasm"
.sub "get_str"  :subid("35_1781909138.43249") :method :outer("32_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 98
    new $P1097, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1097, control_1096
    push_eh $P1097
    .lex "self", self
    .return ("EndOfRunloop()")
  control_1096:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Op"]
.sub "_block1098"  :subid("36_1781909138.43249") :outer("32_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 104
    .const 'Sub' $P1131 = "40_1781909138.43249" 
    capture_lex $P1131
    .const 'Sub' $P1122 = "39_1781909138.43249" 
    capture_lex $P1122
    .const 'Sub' $P1108 = "38_1781909138.43249" 
    capture_lex $P1108
    .const 'Sub' $P1100 = "37_1781909138.43249" 
    capture_lex $P1100
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 138
    .const 'Sub' $P1131 = "40_1781909138.43249" 
    capture_lex $P1131
    $P101 = $P1131()
.annotate 'line', 104
    .return ($P101)
    .const 'Sub' $P1176 = "45_1781909138.43249" 
    .return ($P1176)
.end


.namespace ["ProfTest";"Want";"Op"]
.sub "" :load :init :subid("post83") :outer("36_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 104
    .const 'Sub' $P1099 = "36_1781909138.43249" 
    .local pmc block
    set block, $P1099
    $P1178 = get_root_global ["parrot"], "P6metaclass"
    $P1178."new_class"("ProfTest::Want::CS", "ProfTest::Want" :named("parent"))
.end


.namespace ["ProfTest";"Want";"Op"]
.include "except_types.pasm"
.sub "new"  :subid("37_1781909138.43249") :method :outer("36_1781909138.43249")
    .param pmc param_1103
    .param pmc param_1104 :optional
    .param int has_param_1104 :opt_flag
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 104
    new $P1102, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1102, control_1101
    push_eh $P1102
    .lex "self", self
    .lex "$name", param_1103
    if has_param_1104, optparam_84
    new $P100, "Undef"
    set param_1104, $P100
  optparam_84:
    .lex "$line", param_1104
.annotate 'line', 105
    find_lex $P101, "$name"
    find_lex $P1105, "self"
    unless_null $P1105, vivify_85
    $P1105 = root_new ['parrot';'Hash']
    store_lex "self", $P1105
  vivify_85:
    set $P1105["name"], $P101
.annotate 'line', 106
    find_lex $P101, "$line"
    unless $P101, if_1106_end
.annotate 'line', 107
    find_lex $P102, "$line"
    find_lex $P1107, "self"
    unless_null $P1107, vivify_86
    $P1107 = root_new ['parrot';'Hash']
    store_lex "self", $P1107
  vivify_86:
    set $P1107["line"], $P102
  if_1106_end:
.annotate 'line', 104
    find_lex $P101, "self"
    .return ($P101)
  control_1101:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"Op"]
.include "except_types.pasm"
.sub "accepts"  :subid("38_1781909138.43249") :method :outer("36_1781909138.43249")
    .param pmc param_1111
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 112
    new $P1110, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1110, control_1109
    push_eh $P1110
    .lex "self", self
    .lex "%prof_line", param_1111
.annotate 'line', 113
    find_lex $P1113, "%prof_line"
    unless_null $P1113, vivify_87
    $P1113 = root_new ['parrot';'Hash']
  vivify_87:
    set $P100, $P1113["type"]
    unless_null $P100, vivify_88
    new $P100, "Undef"
  vivify_88:
    set $S100, $P100
    iseq $I100, $S100, "OP"
    unless $I100, if_1112_end
.annotate 'line', 114
    find_lex $P1115, "self"
    unless_null $P1115, vivify_89
    $P1115 = root_new ['parrot';'Hash']
  vivify_89:
    set $P101, $P1115["name"]
    unless_null $P101, vivify_90
    new $P101, "Undef"
  vivify_90:
    set $S101, $P101
    find_lex $P1116, "%prof_line"
    unless_null $P1116, vivify_91
    $P1116 = root_new ['parrot';'Hash']
  vivify_91:
    set $P102, $P1116["op"]
    unless_null $P102, vivify_92
    new $P102, "Undef"
  vivify_92:
    set $S102, $P102
    isne $I101, $S101, $S102
    unless $I101, if_1114_end
.annotate 'line', 115
    new $P103, "Exception"
    set $P103['type'], .CONTROL_RETURN
    new $P104, "Integer"
    assign $P104, 0
    setattribute $P103, 'payload', $P104
    throw $P103
  if_1114_end:
.annotate 'line', 117
    find_lex $P1119, "self"
    unless_null $P1119, vivify_93
    $P1119 = root_new ['parrot';'Hash']
  vivify_93:
    set $P102, $P1119["line"]
    unless_null $P102, vivify_94
    new $P102, "Undef"
  vivify_94:
    if $P102, if_1118
    set $P101, $P102
    goto if_1118_end
  if_1118:
    find_lex $P1120, "self"
    unless_null $P1120, vivify_95
    $P1120 = root_new ['parrot';'Hash']
  vivify_95:
    set $P103, $P1120["line"]
    unless_null $P103, vivify_96
    new $P103, "Undef"
  vivify_96:
    set $N100, $P103
    find_lex $P1121, "%prof_line"
    unless_null $P1121, vivify_97
    $P1121 = root_new ['parrot';'Hash']
  vivify_97:
    set $P104, $P1121["line"]
    unless_null $P104, vivify_98
    new $P104, "Undef"
  vivify_98:
    set $N101, $P104
    isne $I101, $N100, $N101
    new $P101, 'Integer'
    set $P101, $I101
  if_1118_end:
    unless $P101, if_1117_end
.annotate 'line', 118
    new $P105, "Exception"
    set $P105['type'], .CONTROL_RETURN
    new $P106, "Integer"
    assign $P106, 0
    setattribute $P105, 'payload', $P106
    throw $P105
  if_1117_end:
.annotate 'line', 120
    new $P101, "Exception"
    set $P101['type'], .CONTROL_RETURN
    new $P102, "Integer"
    assign $P102, 1
    setattribute $P101, 'payload', $P102
    throw $P101
  if_1112_end:
.annotate 'line', 122
    new $P100, "Exception"
    set $P100['type'], .CONTROL_RETURN
    new $P101, "Integer"
    assign $P101, 0
    setattribute $P100, 'payload', $P101
    throw $P100
.annotate 'line', 112
    .return ()
  control_1109:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Op"]
.include "except_types.pasm"
.sub "get_str"  :subid("39_1781909138.43249") :method :outer("36_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 125
    new $P1124, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1124, control_1123
    push_eh $P1124
    .lex "self", self
.annotate 'line', 126
    new $P100, "Undef"
    set $P1125, $P100
    .lex "$str", $P1125
    new $P101, "String"
    assign $P101, "Op("
    find_lex $P1126, "self"
    unless_null $P1126, vivify_99
    $P1126 = root_new ['parrot';'Hash']
  vivify_99:
    set $P102, $P1126["name"]
    unless_null $P102, vivify_100
    new $P102, "Undef"
  vivify_100:
    concat $P103, $P101, $P102
    store_lex "$str", $P103
.annotate 'line', 127
    find_lex $P1128, "self"
    unless_null $P1128, vivify_101
    $P1128 = root_new ['parrot';'Hash']
  vivify_101:
    set $P101, $P1128["line"]
    unless_null $P101, vivify_102
    new $P101, "Undef"
  vivify_102:
    unless $P101, if_1127_end
.annotate 'line', 128
    find_lex $P102, "$str"
    concat $P103, $P102, ", :line("
    find_lex $P1129, "self"
    unless_null $P1129, vivify_103
    $P1129 = root_new ['parrot';'Hash']
  vivify_103:
    set $P104, $P1129["line"]
    unless_null $P104, vivify_104
    new $P104, "Undef"
  vivify_104:
    concat $P105, $P103, $P104
    concat $P106, $P105, ")"
    store_lex "$str", $P106
  if_1127_end:
.annotate 'line', 130
    find_lex $P101, "$str"
    concat $P102, $P101, ")"
    store_lex "$str", $P102
.annotate 'line', 125
    find_lex $P101, "$str"
    .return ($P101)
  control_1123:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"CS"]
.sub "_block1130"  :subid("40_1781909138.43249") :outer("36_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 138
    .const 'Sub' $P1161 = "43_1781909138.43249" 
    capture_lex $P1161
    .const 'Sub' $P1141 = "42_1781909138.43249" 
    capture_lex $P1141
    .const 'Sub' $P1132 = "41_1781909138.43249" 
    capture_lex $P1132
    $P0 = find_dynamic_lex "$*CTXSAVE"
    if null $P0 goto ctxsave_done
    $I0 = can $P0, "ctxsave"
    unless $I0 goto ctxsave_done
    $P0."ctxsave"()
  ctxsave_done:
.annotate 'line', 167
    .const 'Sub' $P1161 = "43_1781909138.43249" 
    newclosure $P1171, $P1161
.annotate 'line', 138
    .return ($P1171)
    .const 'Sub' $P1173 = "44_1781909138.43249" 
    .return ($P1173)
.end


.namespace ["ProfTest";"Want";"CS"]
.include "except_types.pasm"
.sub "new"  :subid("41_1781909138.43249") :method :outer("40_1781909138.43249")
    .param pmc param_1135 :optional :named("ns")
    .param int has_param_1135 :opt_flag
    .param pmc param_1136 :optional :named("slurp_until")
    .param int has_param_1136 :opt_flag
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 138
    new $P1134, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1134, control_1133
    push_eh $P1134
    .lex "self", self
    if has_param_1135, optparam_105
    new $P100, "Undef"
    set param_1135, $P100
  optparam_105:
    .lex "$ns", param_1135
    if has_param_1136, optparam_106
    new $P101, "Undef"
    set param_1136, $P101
  optparam_106:
    .lex "$slurp_until", param_1136
.annotate 'line', 139
    find_lex $P102, "$ns"
    find_lex $P1137, "self"
    unless_null $P1137, vivify_107
    $P1137 = root_new ['parrot';'Hash']
    store_lex "self", $P1137
  vivify_107:
    set $P1137["ns"], $P102
.annotate 'line', 140
    find_lex $P102, "$slurp_until"
    unless $P102, if_1138_end
.annotate 'line', 141
    find_lex $P103, "$slurp_until"
    find_lex $P1139, "self"
    unless_null $P1139, vivify_108
    $P1139 = root_new ['parrot';'Hash']
    store_lex "self", $P1139
  vivify_108:
    set $P1139["slurp_until"], $P103
  if_1138_end:
.annotate 'line', 143
    new $P102, "Integer"
    assign $P102, 0
    find_lex $P1140, "self"
    unless_null $P1140, vivify_109
    $P1140 = root_new ['parrot';'Hash']
    store_lex "self", $P1140
  vivify_109:
    set $P1140["found_cs"], $P102
.annotate 'line', 138
    find_lex $P102, "self"
    .return ($P102)
  control_1133:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P103, exception, "payload"
    .return ($P103)
.end


.namespace ["ProfTest";"Want";"CS"]
.include "except_types.pasm"
.sub "accepts"  :subid("42_1781909138.43249") :method :outer("40_1781909138.43249")
    .param pmc param_1144
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 147
    new $P1143, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1143, control_1142
    push_eh $P1143
    .lex "self", self
    .lex "%prof_line", param_1144
.annotate 'line', 148
    find_lex $P1147, "self"
    unless_null $P1147, vivify_110
    $P1147 = root_new ['parrot';'Hash']
  vivify_110:
    set $P101, $P1147["found_cs"]
    unless_null $P101, vivify_111
    new $P101, "Undef"
  vivify_111:
    if $P101, if_1146
    set $P100, $P101
    goto if_1146_end
  if_1146:
    find_lex $P1148, "self"
    unless_null $P1148, vivify_112
    $P1148 = root_new ['parrot';'Hash']
  vivify_112:
    set $P102, $P1148["slurp_until"]
    unless_null $P102, vivify_113
    new $P102, "Undef"
  vivify_113:
    set $P100, $P102
  if_1146_end:
    if $P100, if_1145
.annotate 'line', 154
    find_lex $P1153, "%prof_line"
    unless_null $P1153, vivify_114
    $P1153 = root_new ['parrot';'Hash']
  vivify_114:
    set $P103, $P1153["type"]
    unless_null $P103, vivify_115
    new $P103, "Undef"
  vivify_115:
    set $S100, $P103
    iseq $I100, $S100, "CS"
    unless $I100, if_1152_end
.annotate 'line', 155
    find_lex $P1155, "self"
    unless_null $P1155, vivify_116
    $P1155 = root_new ['parrot';'Hash']
  vivify_116:
    set $P104, $P1155["ns"]
    unless_null $P104, vivify_117
    new $P104, "Undef"
  vivify_117:
    isfalse $I101, $P104
    unless $I101, if_1154_end
.annotate 'line', 156
    new $P105, "Integer"
    assign $P105, 1
    find_lex $P1156, "self"
    unless_null $P1156, vivify_118
    $P1156 = root_new ['parrot';'Hash']
    store_lex "self", $P1156
  vivify_118:
    set $P1156["found_cs"], $P105
.annotate 'line', 157
    new $P105, "Exception"
    set $P105['type'], .CONTROL_RETURN
    new $P106, "Integer"
    assign $P106, 1
    setattribute $P105, 'payload', $P106
    throw $P105
  if_1154_end:
.annotate 'line', 159
    find_lex $P1158, "%prof_line"
    unless_null $P1158, vivify_119
    $P1158 = root_new ['parrot';'Hash']
  vivify_119:
    set $P104, $P1158["ns"]
    unless_null $P104, vivify_120
    new $P104, "Undef"
  vivify_120:
    set $S101, $P104
    find_lex $P1159, "self"
    unless_null $P1159, vivify_121
    $P1159 = root_new ['parrot';'Hash']
  vivify_121:
    set $P105, $P1159["ns"]
    unless_null $P105, vivify_122
    new $P105, "Undef"
  vivify_122:
    set $S102, $P105
    iseq $I101, $S101, $S102
    unless $I101, if_1157_end
.annotate 'line', 160
    new $P106, "Integer"
    assign $P106, 1
    find_lex $P1160, "self"
    unless_null $P1160, vivify_123
    $P1160 = root_new ['parrot';'Hash']
    store_lex "self", $P1160
  vivify_123:
    set $P1160["found_cs"], $P106
.annotate 'line', 161
    new $P106, "Exception"
    set $P106['type'], .CONTROL_RETURN
    new $P107, "Integer"
    assign $P107, 1
    setattribute $P106, 'payload', $P107
    throw $P106
  if_1157_end:
  if_1152_end:
.annotate 'line', 154
    goto if_1145_end
  if_1145:
.annotate 'line', 149
    find_lex $P1150, "%prof_line"
    unless_null $P1150, vivify_124
    $P1150 = root_new ['parrot';'Hash']
  vivify_124:
    set $P103, $P1150["type"]
    unless_null $P103, vivify_125
    new $P103, "Undef"
  vivify_125:
    set $S100, $P103
    downcase $S101, $S100
    find_lex $P1151, "self"
    unless_null $P1151, vivify_126
    $P1151 = root_new ['parrot';'Hash']
  vivify_126:
    set $P104, $P1151["slurp_until"]
    unless_null $P104, vivify_127
    new $P104, "Undef"
  vivify_127:
    set $S102, $P104
    isne $I100, $S101, $S102
    unless $I100, if_1149_end
.annotate 'line', 150
    new $P105, "Exception"
    set $P105['type'], .CONTROL_RETURN
    new $P106, "Integer"
    assign $P106, 1
    setattribute $P105, 'payload', $P106
    throw $P105
  if_1149_end:
.annotate 'line', 152
    new $P103, "Exception"
    set $P103['type'], .CONTROL_RETURN
    new $P104, "Integer"
    assign $P104, 0
    setattribute $P103, 'payload', $P104
    throw $P103
  if_1145_end:
.annotate 'line', 164
    new $P100, "Exception"
    set $P100['type'], .CONTROL_RETURN
    new $P101, "Integer"
    assign $P101, 0
    setattribute $P100, 'payload', $P101
    throw $P100
.annotate 'line', 147
    .return ()
  control_1142:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P100, exception, "payload"
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"CS"]
.include "except_types.pasm"
.sub "get_str"  :subid("43_1781909138.43249") :method :outer("40_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 167
    new $P1163, 'ExceptionHandler', [.CONTROL_RETURN]
    set_label $P1163, control_1162
    push_eh $P1163
    .lex "self", self
.annotate 'line', 168
    new $P100, "Undef"
    set $P1164, $P100
    .lex "$str", $P1164
    new $P101, "String"
    assign $P101, "CS("
    store_lex "$str", $P101
.annotate 'line', 169
    find_lex $P1166, "self"
    unless_null $P1166, vivify_128
    $P1166 = root_new ['parrot';'Hash']
  vivify_128:
    set $P101, $P1166["ns"]
    unless_null $P101, vivify_129
    new $P101, "Undef"
  vivify_129:
    unless $P101, if_1165_end
.annotate 'line', 170
    find_lex $P102, "$str"
    concat $P103, $P102, ":ns("
    find_lex $P1167, "self"
    unless_null $P1167, vivify_130
    $P1167 = root_new ['parrot';'Hash']
  vivify_130:
    set $P104, $P1167["ns"]
    unless_null $P104, vivify_131
    new $P104, "Undef"
  vivify_131:
    concat $P105, $P103, $P104
    concat $P106, $P105, ")"
    store_lex "$str", $P106
  if_1165_end:
.annotate 'line', 172
    find_lex $P1169, "self"
    unless_null $P1169, vivify_132
    $P1169 = root_new ['parrot';'Hash']
  vivify_132:
    set $P101, $P1169["slurp_until"]
    unless_null $P101, vivify_133
    new $P101, "Undef"
  vivify_133:
    unless $P101, if_1168_end
.annotate 'line', 173
    find_lex $P102, "$str"
    concat $P103, $P102, ", :slurp_until("
    find_lex $P1170, "self"
    unless_null $P1170, vivify_134
    $P1170 = root_new ['parrot';'Hash']
  vivify_134:
    set $P104, $P1170["slurp_until"]
    unless_null $P104, vivify_135
    new $P104, "Undef"
  vivify_135:
    concat $P105, $P103, $P104
    concat $P106, $P105, ")"
    store_lex "$str", $P106
  if_1168_end:
.annotate 'line', 175
    find_lex $P101, "$str"
    concat $P102, $P101, ")"
    store_lex "$str", $P102
.annotate 'line', 167
    find_lex $P101, "$str"
    .return ($P101)
  control_1162:
    .local pmc exception 
    .get_results (exception) 
    getattribute $P102, exception, "payload"
    .return ($P102)
.end


.namespace ["ProfTest";"Want";"CS"]
.sub "_block1172" :load :anon :subid("44_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 138
    .const '' $P1174 = "40_1781909138.43249" 
    $P100 = $P1174()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Op"]
.sub "_block1175" :load :anon :subid("45_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 104
    .const '' $P1177 = "36_1781909138.43249" 
    $P100 = $P1177()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"EndOfRunloop"]
.sub "_block1179" :load :anon :subid("46_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 90
    .const '' $P1181 = "32_1781909138.43249" 
    $P100 = $P1181()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"CLI"]
.sub "_block1183" :load :anon :subid("47_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 76
    .const '' $P1185 = "28_1781909138.43249" 
    $P100 = $P1185()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Version"]
.sub "_block1187" :load :anon :subid("48_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 52
    .const '' $P1189 = "24_1781909138.43249" 
    $P100 = $P1189()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Any"]
.sub "_block1191" :load :anon :subid("49_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 25
    .const '' $P1193 = "19_1781909138.43249" 
    $P100 = $P1193()
    .return ($P100)
.end


.namespace ["ProfTest";"Want";"Goal"]
.sub "_block1195" :load :anon :subid("50_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 15
    .const '' $P1197 = "15_1781909138.43249" 
    $P100 = $P1197()
    .return ($P100)
.end


.namespace ["ProfTest";"Want"]
.sub "_block1199" :load :anon :subid("51_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 6
    .const '' $P1201 = "11_1781909138.43249" 
    $P100 = $P1201()
    .return ($P100)
.end


.namespace []
.sub "_block1203" :load :anon :subid("52_1781909138.43249")
.annotate 'file', "runtime/parrot/library/ProfTest/Want.nqp"
.annotate 'line', 1
    .const '' $P1205 = "10_1781909138.43249" 
    $P100 = $P1205()
    .return ($P100)
.end

