Skip to content

Instantly share code, notes, and snippets.

@norio-nomura

norio-nomura/indexof-O.sil

Created January 15, 2015 01:55
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save norio-nomura/e30c5450acfbc0bbf9d9 to your computer and use it in GitHub Desktop.
Save norio-nomura/e30c5450acfbc0bbf9d9 to your computer and use it in GitHub Desktop.
Download ZIP
`swift-demangle-filter.py -emit-sil -O indexof.swift -o indexof-O.sil`
Raw
indexof-O.sil
This file has been truncated, but you can view the full file.
sil_stage canonical
import Builtin
import Swift
import SwiftShims
// indexof.a : Swift.Array<Swift.Int>
sil_global indexof.a : [Swift.Int] : $Array<Int>
// indexof.c (Swift.Int) -> Swift.Bool
sil_global indexof.c (Swift.Int) -> Swift.Bool : $@callee_owned (Int) -> Bool
// indexof.result1 : Swift.Optional<Swift.Int>
sil_global indexof.result1 : Swift.Int? : $Optional<Int>
// indexof.result2 : Swift.Optional<Swift.Int>
sil_global indexof.result2 : Swift.Int? : $Optional<Int>
// top_level_code
sil private @top_level_code : $@thin () -> () {
bb0:
%0 = sil_global_addr indexof.a : [Swift.Int] : $*Array<Int> // users: %240, %324
%1 = integer_literal $Builtin.Word, 1 // users: %2, %9, %81, %83, %99, %101, %115, %178, %198, %201, %288, %290, %340, %364, %366, %397, %413, %415, %441, %460, %462, %510, %540, %542, %553
%2 = struct $Int (%1 : $Builtin.Word) // user: %8
%3 = integer_literal $Builtin.Word, 2 // users: %4, %11
%4 = struct $Int (%3 : $Builtin.Word) // user: %10
%5 = integer_literal $Builtin.Word, 3 // users: %6, %7#0, %34
%6 = struct $Int (%5 : $Builtin.Word) // user: %12
%7 = alloc_array $Int, %5 : $Builtin.Word // users: %8, %9, %11, %13, %235
store %2 to %7#1 : $*Int // id: %8
%9 = index_addr %7#1 : $*Int, %1 : $Builtin.Word // user: %10
store %4 to %9 : $*Int // id: %10
%11 = index_addr %7#1 : $*Int, %3 : $Builtin.Word // user: %12
store %6 to %11 : $*Int // id: %12
%13 = address_to_pointer %7#1 : $*Int to $Builtin.RawPointer // user: %25
%14 = integer_literal $Builtin.Int1, -1 // users: %23, %32, %39, %76, %90, %95, %105, %109, %133, %142, %160, %189, %222, %255, %267, %272, %283, %299, %350, %359, %375, %391, %395, %401, %404, %409, %455, %471, %513, %520, %524, %528, %531, %536, %553
%15 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %17, %19, %28, %30, %71, %89, %129, %131, %138, %140, %218, %220, %265, %270, %278, %297, %355, %373, %403, %450, %469, %530
%16 = metatype $@thick Builtin.RawPointer.Type // user: %17
%17 = apply %15<Builtin.RawPointer>(%16) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%18 = metatype $@thick UnsafeMutablePointer<Int>.Type // user: %19
%19 = apply %15<UnsafeMutablePointer<Int>>(%18) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%20 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %21, %31, %47, %50, %52, %58, %132, %141, %164, %191, %208, %221, %266, %271, %298, %312, %374, %439, %470, %485, %503, %505
%21 = apply %20(%17, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %23
%22 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %23, %32, %39, %133, %142, %189, %222, %267, %272, %299, %350, %375, %391, %395, %401, %471, %513, %520, %524, %528
%23 = apply %22(%21, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %24
cond_fail %23 : $Builtin.Int1 // id: %24
%25 = unchecked_trivial_bit_cast %13 : $Builtin.RawPointer to $UnsafeMutablePointer<Int> // user: %26
%26 = struct_extract %25 : $UnsafeMutablePointer<Int>, #UnsafeMutablePointer.value // user: %203
%27 = metatype $@thick Builtin.Word.Type // user: %28
%28 = apply %15<Builtin.Word>(%27) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %31
%29 = metatype $@thick Int.Type // users: %30, %42, %94, %408, %535
%30 = apply %15<Int>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %31
%31 = apply %20(%28, %30) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %32
%32 = apply %22(%31, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %33
cond_fail %32 : $Builtin.Int1 // id: %33
%34 = unchecked_trivial_bit_cast %5 : $Builtin.Word to $Int // user: %37
%35 = integer_literal $Builtin.Word, 0 // users: %38, %47, %58, %66, %67, %152, %153, %180, %188, %191, %194, %194, %312, %338, %353, %485, %487, %487, %505, %515
%36 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %38, %353, %515
%37 = struct_extract %34 : $Int, #Int.value // users: %38, %45
%38 = apply %36(%37, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %39
%39 = apply %22(%38, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %40
cond_fail %39 : $Builtin.Int1 // id: %40
%41 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %42, %147, %304, %380, %476
%42 = apply %41<Int>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %45, %47, %52, %57, %105, %167, %200
%43 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %45, %105, %148, %184, %305, %381, %419, %477, %546
%44 = integer_literal $Builtin.Int1, 0 // users: %45, %81, %83, %99, %101, %115, %148, %184, %198, %201, %288, %290, %305, %364, %366, %381, %397, %413, %415, %419, %441, %460, %462, %477, %510, %540, %542, %546
%45 = apply %43(%37, %42, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %46
%46 = tuple_extract %45 : $(Builtin.Word, Builtin.Int1), 0 // users: %50, %57
%47 = apply %20(%42, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %48
cond_fail %47 : $Builtin.Int1 // id: %48
%49 = integer_literal $Builtin.Word, -9223372036854775808 // users: %50, %164
%50 = apply %20(%46, %49) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %54
%51 = integer_literal $Builtin.Word, -1 // users: %52, %86, %103, %293, %369, %417, %465, %544
%52 = apply %20(%42, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %54, %165
%53 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %54, %165, %390, %519
%54 = apply %53(%50, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %55
cond_fail %54 : $Builtin.Int1 // id: %55
%56 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %57, %167
%57 = apply %56(%46, %42) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %58, %62, %66, %68, %188, %191, %208
%58 = apply %20(%57, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %59
cond_br %58, bb1, bb2 // id: %59
bb1: // Preds: bb0
%60 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %61
br bb15(%60 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %61
bb2: // Preds: bb0
%62 = struct $Int (%57 : $Builtin.Word) // user: %182
%63 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %64
%64 = upcast %63 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %127
%65 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %66, %120, %122, %211
%66 = apply %65(%35, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %67
cond_br %66, bb3, bb4(%35 : $Builtin.Word) // id: %67
bb3: // Preds: bb2
br bb4(%57 : $Builtin.Word) // id: %68
bb4(%69 : $Builtin.Word): // Preds: bb2 bb3
%70 = metatype $@thick HeapObject.Type // users: %71, %114
%71 = apply %15<HeapObject>(%70) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %76
%72 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %74, %94, %114
%73 = metatype $@thick _ArrayBody.Type // users: %74, %89
%74 = apply %72<_ArrayBody>(%73) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %76, %83
%75 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %76, %90, %95, %109, %198, %201
%76 = apply %75(%71, %74, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %77, %78
%77 = tuple_extract %76 : $(Builtin.Word, Builtin.Int1), 0 // user: %81
%78 = tuple_extract %76 : $(Builtin.Word, Builtin.Int1), 1 // user: %79
cond_fail %78 : $Builtin.Int1 // id: %79
%80 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %81, %83, %99, %101, %115, %160
%81 = apply %80(%77, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %82
%82 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 0 // user: %88
%83 = apply %80(%74, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %84
%84 = tuple_extract %83 : $(Builtin.Word, Builtin.Int1), 0 // users: %86, %118, %120, %122
%85 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %86, %103
%86 = apply %85(%84, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %88
%87 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %88, %104
%88 = apply %87(%82, %86) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %90, %148
%89 = apply %15<_ArrayBody>(%73) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %90
%90 = apply %75(%88, %89, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %91, %92
%91 = tuple_extract %90 : $(Builtin.Word, Builtin.Int1), 0 // user: %95
%92 = tuple_extract %90 : $(Builtin.Word, Builtin.Int1), 1 // user: %93
cond_fail %92 : $Builtin.Int1 // id: %93
%94 = apply %72<Int>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %95, %101
%95 = apply %75(%91, %94, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %96, %97
%96 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 0 // user: %99
%97 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = apply %80(%96, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %100
%100 = tuple_extract %99 : $(Builtin.Word, Builtin.Int1), 0 // user: %104
%101 = apply %80(%94, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %102
%102 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 0 // users: %103, %119, %122, %211
%103 = apply %85(%102, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %104
%104 = apply %87(%100, %103) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %109, %160, %184
%105 = apply %43(%69, %42, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %106, %107
%106 = tuple_extract %105 : $(Builtin.Word, Builtin.Int1), 0 // user: %109
%107 = tuple_extract %105 : $(Builtin.Word, Builtin.Int1), 1 // user: %108
cond_fail %107 : $Builtin.Int1 // id: %108
%109 = apply %75(%104, %106, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %110, %111
%110 = tuple_extract %109 : $(Builtin.Word, Builtin.Int1), 0 // user: %113
%111 = tuple_extract %109 : $(Builtin.Word, Builtin.Int1), 1 // user: %112
cond_fail %111 : $Builtin.Int1 // id: %112
%113 = struct $Int (%110 : $Builtin.Word) // user: %127
%114 = apply %72<HeapObject>(%70) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %115
%115 = apply %80(%114, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %116
%116 = tuple_extract %115 : $(Builtin.Word, Builtin.Int1), 0 // users: %117, %120, %211
%117 = struct $Int (%116 : $Builtin.Word) // user: %214
%118 = struct $Int (%84 : $Builtin.Word) // user: %210
%119 = struct $Int (%102 : $Builtin.Word) // users: %124, %213
%120 = apply %65(%116, %84) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %121
cond_br %120, bb5, bb12 // id: %121
bb5: // Preds: bb4
%122 = apply %65(%84, %102) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %123
cond_br %122, bb6, bb11 // id: %123
bb6: // Preds: bb5
br bb7(%119 : $Int) // id: %124
bb7(%125 : $Int): // Preds: bb6 bb11 bb13 bb14
// function_ref swift_bufferAllocate
%126 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %127
%127 = apply %126(%64, %113, %125) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %135
%128 = metatype $@thick AnyObject.Protocol // user: %129
%129 = apply %15<AnyObject>(%128) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %132
%130 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %131
%131 = apply %15<HeapBufferStorage<_ArrayBody, Int>>(%130) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %132
%132 = apply %20(%129, %131) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %133
%133 = apply %22(%132, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %134
cond_fail %133 : $Builtin.Int1 // id: %134
%135 = unchecked_ref_bit_cast %127 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %136
%136 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %135 : $HeapBufferStorage<_ArrayBody, Int> // users: %144, %193
%137 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %138
%138 = apply %15<HeapBufferStorage<_ArrayBody, Int>?>(%137) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %141
%139 = metatype $@thick Builtin.NativeObject.Type // user: %140
%140 = apply %15<Builtin.NativeObject>(%139) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %141
%141 = apply %20(%138, %140) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %142
%142 = apply %22(%141, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %143
cond_fail %142 : $Builtin.Int1 // id: %143
%144 = unchecked_ref_bit_cast %136 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %145
%145 = ref_to_raw_pointer %144 : $Builtin.NativeObject to $Builtin.RawPointer // users: %150, %157, %186
%146 = metatype $@thick Int8.Type // user: %147
%147 = apply %41<Int8>(%146) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %148, %184
%148 = apply %43(%88, %147, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %149
%149 = tuple_extract %148 : $(Builtin.Word, Builtin.Int1), 0 // user: %150
%150 = index_raw_pointer %145 : $Builtin.RawPointer, %149 : $Builtin.Word // user: %151
%151 = pointer_to_address %150 : $Builtin.RawPointer to $*_ArrayBody // users: %155, %183
%152 = struct $Int (%35 : $Builtin.Word) // user: %154
%153 = struct $UInt (%35 : $Builtin.Word) // user: %154
%154 = struct $_ArrayBody (%152 : $Int, %153 : $UInt) // user: %155
store %154 to %151 : $*_ArrayBody // id: %155
// function_ref malloc_size
%156 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %158
%157 = struct $UnsafePointer<()> (%145 : $Builtin.RawPointer) // user: %158
%158 = apply %156(%157) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %159
%159 = struct_extract %158 : $UInt, #UInt.value // user: %160
%160 = apply %80(%159, %104, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %161, %162
%161 = tuple_extract %160 : $(Builtin.Word, Builtin.Int1), 0 // users: %164, %167
%162 = tuple_extract %160 : $(Builtin.Word, Builtin.Int1), 1 // user: %163
cond_fail %162 : $Builtin.Int1 // id: %163
%164 = apply %20(%161, %49) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %165
%165 = apply %53(%164, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %166
cond_fail %165 : $Builtin.Int1 // id: %166
%167 = apply %56(%161, %42) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %169
%168 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %169
%169 = apply %168(%167) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %171
%170 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %171
%171 = apply %170(%169) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %172, %173
%172 = tuple_extract %171 : $(Builtin.Int64, Builtin.Int1), 0 // user: %176
%173 = tuple_extract %171 : $(Builtin.Int64, Builtin.Int1), 1 // user: %174
cond_fail %173 : $Builtin.Int1 // id: %174
%175 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %176
%176 = apply %175(%172) : $@thin (Builtin.Int64) -> Builtin.Word // user: %178
%177 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %178
%178 = apply %177(%176, %1) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %180
%179 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %180
%180 = apply %179(%178, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %181
%181 = struct $UInt (%180 : $Builtin.Word) // user: %182
%182 = struct $_ArrayBody (%62 : $Int, %181 : $UInt) // user: %183
store %182 to %151 : $*_ArrayBody // id: %183
%184 = apply %43(%104, %147, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %185
%185 = tuple_extract %184 : $(Builtin.Word, Builtin.Int1), 0 // user: %186
%186 = index_raw_pointer %145 : $Builtin.RawPointer, %185 : $Builtin.Word // user: %194
%187 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %188
%188 = apply %187(%35, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %189
%189 = apply %22(%188, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %190
cond_fail %189 : $Builtin.Int1 // id: %190
%191 = apply %20(%35, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %192
cond_br %191, bb8, bb9 // id: %192
bb8: // Preds: bb7 bb10
br bb15(%136 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %193
bb9: // Preds: bb7
br bb10(%35 : $Builtin.Word, %186 : $Builtin.RawPointer, %35 : $Builtin.Word) // id: %194
bb10(%195 : $Builtin.Word, %196 : $Builtin.RawPointer, %197 : $Builtin.Word): // Preds: bb9 bb10
%198 = apply %75(%195, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %199
%199 = tuple_extract %198 : $(Builtin.Word, Builtin.Int1), 0 // users: %208, %209
%200 = index_raw_pointer %196 : $Builtin.RawPointer, %42 : $Builtin.Word // user: %209
%201 = apply %75(%197, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %202
%202 = tuple_extract %201 : $(Builtin.Word, Builtin.Int1), 0 // user: %209
%203 = pointer_to_address %26 : $Builtin.RawPointer to $*Int // user: %204
%204 = index_addr %203 : $*Int, %197 : $Builtin.Word // user: %205
%205 = load %204 : $*Int // user: %207
%206 = pointer_to_address %196 : $Builtin.RawPointer to $*Int // user: %207
store %205 to %206 : $*Int // id: %207
%208 = apply %20(%199, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %209
cond_br %208, bb8, bb10(%199 : $Builtin.Word, %200 : $Builtin.RawPointer, %202 : $Builtin.Word) // id: %209
bb11: // Preds: bb5
br bb7(%118 : $Int) // id: %210
bb12: // Preds: bb4
%211 = apply %65(%116, %102) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %212
cond_br %211, bb13, bb14 // id: %212
bb13: // Preds: bb12
br bb7(%119 : $Int) // id: %213
bb14: // Preds: bb12
br bb7(%117 : $Int) // id: %214
bb15(%215 : $Optional<HeapBufferStorage<_ArrayBody, Int>>): // Preds: bb1 bb8
%216 = enum $Optional<Builtin.NativeObject>, #Optional.None!enumelt // user: %448
%217 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %218
%218 = apply %15<HeapBufferStorage<_ArrayBody, Int>?>(%217) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %221, %298, %374, %470
%219 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %220
%220 = apply %15<_ContiguousArrayStorage<Int>?>(%219) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %221, %266, %271
%221 = apply %20(%218, %220) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %222
%222 = apply %22(%221, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %223
cond_fail %222 : $Builtin.Int1 // id: %223
%224 = unchecked_ref_bit_cast %215 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %225
%225 = enum_is_tag $Builtin.Int1, %224 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %226
cond_br %225, bb16, bb27 // id: %226
bb16: // Preds: bb15
%227 = unchecked_ref_bit_cast %215 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %228
%228 = unchecked_ref_cast %227 : $_ContiguousArrayStorage<Int> to $Builtin.NativeObject // user: %229
%229 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %228 : $Builtin.NativeObject // user: %230
br bb17(%229 : $Optional<Builtin.NativeObject>) // id: %230
bb17(%231 : $Optional<Builtin.NativeObject>): // Preds: bb16 bb27
%232 = struct $_ArrayBuffer<Int> (%231 : $Optional<Builtin.NativeObject>) // user: %233
%233 = struct $Array<Int> (%232 : $_ArrayBuffer<Int>) // users: %240, %251
%234 = alloc_stack $Builtin.NativeObject // users: %235, %236, %237, %239
store %7#0 to %234#1 : $*Builtin.NativeObject // id: %235
fix_lifetime %234#1 : $*Builtin.NativeObject // id: %236
%237 = load %234#1 : $*Builtin.NativeObject // user: %238
strong_release %237 : $Builtin.NativeObject // id: %238
dealloc_stack %234#0 : $*@local_storage Builtin.NativeObject // id: %239
store %233 to %0 : $*Array<Int> // id: %240
%241 = sil_global_addr indexof.c (Swift.Int) -> Swift.Bool : $*@callee_owned (Int) -> Bool // users: %244, %327
// function_ref indexof.(closure #1)
%242 = function_ref indexof.(closure #1) : $@thin (Int) -> Bool // user: %243
%243 = thin_to_thick_function %242 : $@thin (Int) -> Bool to $@callee_owned (Int) -> Bool // user: %244
store %243 to %241 : $*@callee_owned (Int) -> Bool // id: %244
%245 = sil_global_addr indexof.result1 : Swift.Int? : $*Optional<Int> // users: %315, %437
// function_ref reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool) with unmangled suffix "_constprop0"
%246 = function_ref reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool) with unmangled suffix "_constprop0" : $@thin (@in Int) -> Bool // user: %247
%247 = thin_to_thick_function %246 : $@thin (@in Int) -> Bool to $@callee_owned (@in Int) -> Bool // user: %250
%248 = alloc_stack $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // users: %253, %258, %322
// function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool)
%249 = function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %250
%250 = partial_apply %249<[Int], IndexingGenerator<Array<Int>>, Int, Int, Int, Int, Int, Int>(%247) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %251
%251 = struct $MapCollectionView<Array<Int>, Bool> (%233 : $Array<Int>, %250 : $@callee_owned (@out Bool, @in Int) -> ()) // user: %252
%252 = struct $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> (%251 : $MapCollectionView<Array<Int>, Bool>) // user: %253
store %252 to %248#1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %253
%254 = alloc_stack $Bool // users: %256, %321, %429
%255 = struct $Bool (%14 : $Builtin.Int1) // user: %256
store %255 to %254#1 : $*Bool // id: %256
retain_value %231 : $Optional<Builtin.NativeObject> // id: %257
%258 = struct_element_addr %248#1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %259, %263
%259 = struct_element_addr %258 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %260
%260 = struct_element_addr %259 : $*Array<Int>, #Array._buffer // user: %261
%261 = struct_element_addr %260 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %262, %317, %345
%262 = load %261 : $*Optional<Builtin.NativeObject> // users: %274, %301, %446
%263 = struct_element_addr %258 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // users: %318, %346
%264 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %265
%265 = apply %15<Builtin.NativeObject?>(%264) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %266
%266 = apply %20(%265, %220) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %267
%267 = apply %22(%266, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %268
cond_fail %267 : $Builtin.Int1 // id: %268
%269 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %270
%270 = apply %15<HeapBuffer<_ArrayBody, Int>>(%269) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %271
%271 = apply %20(%220, %270) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %272
%272 = apply %22(%271, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %273
cond_fail %272 : $Builtin.Int1 // id: %273
%274 = unchecked_ref_bit_cast %262 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %275
%275 = enum_is_tag $Builtin.Int1, %274 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %276
cond_br %275, bb18, bb26 // id: %276
bb18: // Preds: bb17
%277 = metatype $@thick HeapObject.Type // user: %278
%278 = apply %15<HeapObject>(%277) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %283
%279 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %281
%280 = metatype $@thick _ArrayBody.Type // user: %281
%281 = apply %279<_ArrayBody>(%280) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %283, %290
%282 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %283
%283 = apply %282(%278, %281, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %284, %285
%284 = tuple_extract %283 : $(Builtin.Word, Builtin.Int1), 0 // user: %288
%285 = tuple_extract %283 : $(Builtin.Word, Builtin.Int1), 1 // user: %286
cond_fail %285 : $Builtin.Int1 // id: %286
%287 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %288, %290
%288 = apply %287(%284, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %289
%289 = tuple_extract %288 : $(Builtin.Word, Builtin.Int1), 0 // user: %295
%290 = apply %287(%281, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %291
%291 = tuple_extract %290 : $(Builtin.Word, Builtin.Int1), 0 // user: %293
%292 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %293
%293 = apply %292(%291, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %295
%294 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %295
%295 = apply %294(%289, %293) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %305
%296 = metatype $@thick Builtin.NativeObject.Type // user: %297
%297 = apply %15<Builtin.NativeObject>(%296) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %298
%298 = apply %20(%218, %297) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %299
%299 = apply %22(%298, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %300
cond_fail %299 : $Builtin.Int1 // id: %300
%301 = unchecked_ref_bit_cast %262 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %302
%302 = ref_to_raw_pointer %301 : $Builtin.NativeObject to $Builtin.RawPointer // user: %307
%303 = metatype $@thick Int8.Type // user: %304
%304 = apply %41<Int8>(%303) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %305
%305 = apply %43(%295, %304, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %306
%306 = tuple_extract %305 : $(Builtin.Word, Builtin.Int1), 0 // user: %307
%307 = index_raw_pointer %302 : $Builtin.RawPointer, %306 : $Builtin.Word // user: %308
%308 = pointer_to_address %307 : $Builtin.RawPointer to $*_ArrayBody // user: %309
%309 = struct_element_addr %308 : $*_ArrayBody, #_ArrayBody.count // user: %310
%310 = struct_element_addr %309 : $*Int, #Int.value // user: %311
%311 = load %310 : $*Builtin.Word // users: %312, %313
%312 = apply %20(%35, %311) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %313
cond_br %312, bb19, bb21(%311 : $Builtin.Word) // id: %313
bb19: // Preds: bb18 bb24 bb26
%314 = enum $Optional<Int>, #Optional.None!enumelt // user: %315
store %314 to %245 : $*Optional<Int> // id: %315
br bb20 // id: %316
bb20: // Preds: bb19 bb23
%317 = load %261 : $*Optional<Builtin.NativeObject> // user: %319
%318 = load %263 : $*@callee_owned (@out Bool, @in Int) -> () // user: %320
release_value %317 : $Optional<Builtin.NativeObject> // id: %319
strong_release %318 : $@callee_owned (@out Bool, @in Int) -> () // id: %320
dealloc_stack %254#0 : $*@local_storage Bool // id: %321
dealloc_stack %248#0 : $*@local_storage LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %322
%323 = sil_global_addr indexof.result2 : Swift.Int? : $*Optional<Int> // users: %490, %493
%324 = struct_element_addr %0 : $*Array<Int>, #Array._buffer // user: %325
%325 = struct_element_addr %324 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %326
%326 = load %325 : $*Optional<Builtin.NativeObject> // users: %328, %329, %332, %333, %473, %484, %488, %494, %497
%327 = load %241 : $*@callee_owned (Int) -> Bool // users: %331, %496, %557, %558
%328 = unchecked_ref_bit_cast %326 : $Optional<Builtin.NativeObject> to $Optional<_ContiguousArrayStorage<Int>> // users: %334, %506
%329 = unchecked_ref_bit_cast %326 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %330, %500, %512
%330 = enum_is_tag $Builtin.Int1, %329 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %335
strong_retain %327 : $@callee_owned (Int) -> Bool // id: %331
retain_value %326 : $Optional<Builtin.NativeObject> // id: %332
retain_value %326 : $Optional<Builtin.NativeObject> // id: %333
retain_value %328 : $Optional<_ContiguousArrayStorage<Int>> // id: %334
cond_br %330, bb28, bb30 // id: %335
bb21(%336 : $Builtin.Word): // Preds: bb18
%337 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %359, %397, %404, %409, %441
%338 = struct $Int (%35 : $Builtin.Word) // user: %339
%339 = enum $Optional<Int>, #Optional.Some!enumelt.1, %338 : $Int // user: %340
br bb22(%1 : $Builtin.Word, %339 : $Optional<Int>) // id: %340
bb22(%341 : $Builtin.Word, %342 : $Optional<Int>): // Preds: bb21 bb25
%343 = unchecked_enum_data %342 : $Optional<Int>, #Optional.Some!enumelt.1 // user: %352
%344 = alloc_stack $Bool // users: %427, %431, %435
%345 = load %261 : $*Optional<Builtin.NativeObject> // users: %348, %377
%346 = load %263 : $*@callee_owned (@out Bool, @in Int) -> () // users: %426, %427
%347 = alloc_stack $Int // users: %425, %427, %428
%348 = unchecked_ref_bit_cast %345 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %349
%349 = enum_is_tag $Builtin.Int1, %348 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %350
%350 = apply %22(%349, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %351
cond_fail %350 : $Builtin.Int1 // id: %351
%352 = struct_extract %343 : $Int, #Int.value // users: %353, %389, %394, %394, %397, %400, %423
%353 = apply %36(%352, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %390
%354 = metatype $@thick HeapObject.Type // user: %355
%355 = apply %15<HeapObject>(%354) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %359
%356 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %358, %408
%357 = metatype $@thick _ArrayBody.Type // users: %358, %403
%358 = apply %356<_ArrayBody>(%357) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %359, %366
%359 = apply %337(%355, %358, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %360, %361
%360 = tuple_extract %359 : $(Builtin.Word, Builtin.Int1), 0 // user: %364
%361 = tuple_extract %359 : $(Builtin.Word, Builtin.Int1), 1 // user: %362
cond_fail %361 : $Builtin.Int1 // id: %362
%363 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %364, %366, %413, %415
%364 = apply %363(%360, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %365
%365 = tuple_extract %364 : $(Builtin.Word, Builtin.Int1), 0 // user: %371
%366 = apply %363(%358, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %367
%367 = tuple_extract %366 : $(Builtin.Word, Builtin.Int1), 0 // user: %369
%368 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %369, %417
%369 = apply %368(%367, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %371
%370 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %371, %418
%371 = apply %370(%365, %369) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %381, %404
%372 = metatype $@thick Builtin.NativeObject.Type // user: %373
%373 = apply %15<Builtin.NativeObject>(%372) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %374
%374 = apply %20(%218, %373) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %375
%375 = apply %22(%374, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %376
cond_fail %375 : $Builtin.Int1 // id: %376
%377 = unchecked_ref_bit_cast %345 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %378
%378 = ref_to_raw_pointer %377 : $Builtin.NativeObject to $Builtin.RawPointer // users: %383, %421
%379 = metatype $@thick Int8.Type // user: %380
%380 = apply %41<Int8>(%379) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %381, %419
%381 = apply %43(%371, %380, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %382
%382 = tuple_extract %381 : $(Builtin.Word, Builtin.Int1), 0 // user: %383
%383 = index_raw_pointer %378 : $Builtin.RawPointer, %382 : $Builtin.Word // user: %384
%384 = pointer_to_address %383 : $Builtin.RawPointer to $*_ArrayBody // user: %385
%385 = struct_element_addr %384 : $*_ArrayBody, #_ArrayBody.count // user: %386
%386 = struct_element_addr %385 : $*Int, #Int.value // user: %387
%387 = load %386 : $*Builtin.Word // user: %389
%388 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %389
%389 = apply %388(%352, %387) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %390
%390 = apply %53(%353, %389) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %391
%391 = apply %22(%390, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %392
cond_fail %391 : $Builtin.Int1 // id: %392
%393 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %394
%394 = apply %393(%352, %352) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %395
%395 = apply %22(%394, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %396
cond_fail %395 : $Builtin.Int1 // id: %396
%397 = apply %337(%352, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %398
%398 = tuple_extract %397 : $(Builtin.Word, Builtin.Int1), 0 // user: %400
%399 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %400
%400 = apply %399(%398, %352) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %401
%401 = apply %22(%400, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %402
cond_fail %401 : $Builtin.Int1 // id: %402
%403 = apply %15<_ArrayBody>(%357) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %404
%404 = apply %337(%371, %403, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %405, %406
%405 = tuple_extract %404 : $(Builtin.Word, Builtin.Int1), 0 // user: %409
%406 = tuple_extract %404 : $(Builtin.Word, Builtin.Int1), 1 // user: %407
cond_fail %406 : $Builtin.Int1 // id: %407
%408 = apply %356<Int>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %409, %415
%409 = apply %337(%405, %408, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %410, %411
%410 = tuple_extract %409 : $(Builtin.Word, Builtin.Int1), 0 // user: %413
%411 = tuple_extract %409 : $(Builtin.Word, Builtin.Int1), 1 // user: %412
cond_fail %411 : $Builtin.Int1 // id: %412
%413 = apply %363(%410, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %414
%414 = tuple_extract %413 : $(Builtin.Word, Builtin.Int1), 0 // user: %418
%415 = apply %363(%408, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %416
%416 = tuple_extract %415 : $(Builtin.Word, Builtin.Int1), 0 // user: %417
%417 = apply %368(%416, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %418
%418 = apply %370(%414, %417) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %419
%419 = apply %43(%418, %380, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %420
%420 = tuple_extract %419 : $(Builtin.Word, Builtin.Int1), 0 // user: %421
%421 = index_raw_pointer %378 : $Builtin.RawPointer, %420 : $Builtin.Word // user: %422
%422 = pointer_to_address %421 : $Builtin.RawPointer to $*Int // user: %423
%423 = index_addr %422 : $*Int, %352 : $Builtin.Word // user: %424
%424 = load %423 : $*Int // user: %425
store %424 to %347#1 : $*Int // id: %425
strong_retain %346 : $@callee_owned (@out Bool, @in Int) -> () // id: %426
%427 = apply %346(%344#1, %347#1) : $@callee_owned (@out Bool, @in Int) -> ()
dealloc_stack %347#0 : $*@local_storage Int // id: %428
%429 = struct_element_addr %254#1 : $*Bool, #Bool.value // user: %430
%430 = load %429 : $*Builtin.Int1 // user: %434
%431 = struct_element_addr %344#1 : $*Bool, #Bool.value // user: %432
%432 = load %431 : $*Builtin.Int1 // user: %434
%433 = builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %434
%434 = apply %433(%432, %430) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %436
dealloc_stack %344#0 : $*@local_storage Bool // id: %435
cond_br %434, bb23, bb24 // id: %436
bb23: // Preds: bb22
store %342 to %245 : $*Optional<Int> // id: %437
br bb20 // id: %438
bb24: // Preds: bb22
%439 = apply %20(%341, %336) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %440
cond_br %439, bb19, bb25 // id: %440
bb25: // Preds: bb24
%441 = apply %337(%341, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %442
%442 = tuple_extract %441 : $(Builtin.Word, Builtin.Int1), 0 // user: %445
%443 = struct $Int (%341 : $Builtin.Word) // user: %444
%444 = enum $Optional<Int>, #Optional.Some!enumelt.1, %443 : $Int // user: %445
br bb22(%442 : $Builtin.Word, %444 : $Optional<Int>) // id: %445
bb26: // Preds: bb17
retain_value %262 : $Optional<Builtin.NativeObject> // id: %446
br bb19 // id: %447
bb27: // Preds: bb15
br bb17(%216 : $Optional<Builtin.NativeObject>) // id: %448
bb28: // Preds: bb20
%449 = metatype $@thick HeapObject.Type // user: %450
%450 = apply %15<HeapObject>(%449) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %455
%451 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %453, %535
%452 = metatype $@thick _ArrayBody.Type // users: %453, %530
%453 = apply %451<_ArrayBody>(%452) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %455, %462
%454 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %455, %510, %531, %536, %553
%455 = apply %454(%450, %453, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %456, %457
%456 = tuple_extract %455 : $(Builtin.Word, Builtin.Int1), 0 // user: %460
%457 = tuple_extract %455 : $(Builtin.Word, Builtin.Int1), 1 // user: %458
cond_fail %457 : $Builtin.Int1 // id: %458
%459 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %460, %462, %540, %542
%460 = apply %459(%456, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %461
%461 = tuple_extract %460 : $(Builtin.Word, Builtin.Int1), 0 // user: %467
%462 = apply %459(%453, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %463
%463 = tuple_extract %462 : $(Builtin.Word, Builtin.Int1), 0 // user: %465
%464 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %465, %544
%465 = apply %464(%463, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %467
%466 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %467, %545
%467 = apply %466(%461, %465) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %477, %531
%468 = metatype $@thick Builtin.NativeObject.Type // user: %469
%469 = apply %15<Builtin.NativeObject>(%468) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %470
%470 = apply %20(%218, %469) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %471
%471 = apply %22(%470, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %472
cond_fail %471 : $Builtin.Int1 // id: %472
%473 = unchecked_ref_bit_cast %326 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %474
%474 = ref_to_raw_pointer %473 : $Builtin.NativeObject to $Builtin.RawPointer // users: %479, %548
%475 = metatype $@thick Int8.Type // user: %476
%476 = apply %41<Int8>(%475) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %477, %546
%477 = apply %43(%467, %476, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %478
%478 = tuple_extract %477 : $(Builtin.Word, Builtin.Int1), 0 // user: %479
%479 = index_raw_pointer %474 : $Builtin.RawPointer, %478 : $Builtin.Word // user: %480
%480 = pointer_to_address %479 : $Builtin.RawPointer to $*_ArrayBody // user: %481
%481 = struct_element_addr %480 : $*_ArrayBody, #_ArrayBody.count // user: %482
%482 = struct_element_addr %481 : $*Int, #Int.value // users: %483, %502, %516
%483 = load %482 : $*Builtin.Word // user: %485
release_value %326 : $Optional<Builtin.NativeObject> // id: %484
%485 = apply %20(%35, %483) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %486
cond_br %485, bb30, bb29 // id: %486
bb29: // Preds: bb28
br bb36(%35 : $Builtin.Word, %35 : $Builtin.Word) // id: %487
bb30: // Preds: bb20 bb28 bb34 bb35
release_value %326 : $Optional<Builtin.NativeObject> // id: %488
%489 = enum $Optional<Int>, #Optional.None!enumelt // user: %490
store %489 to %323 : $*Optional<Int> // id: %490
br bb32 // id: %491
bb31: // Preds: bb36
%492 = enum $Optional<Int>, #Optional.Some!enumelt.1, %552 : $Int // user: %493
store %492 to %323 : $*Optional<Int> // id: %493
release_value %326 : $Optional<Builtin.NativeObject> // id: %494
br bb32 // id: %495
bb32: // Preds: bb30 bb31
strong_release %327 : $@callee_owned (Int) -> Bool // id: %496
release_value %326 : $Optional<Builtin.NativeObject> // id: %497
%498 = tuple () // user: %499
return %498 : $() // id: %499
bb33: // Preds: bb36
%500 = enum_is_tag $Builtin.Int1, %329 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %501
cond_br %500, bb34, bb35 // id: %501
bb34: // Preds: bb33
%502 = load %482 : $*Builtin.Word // user: %503
%503 = apply %20(%511, %502) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %504
cond_br %503, bb30, bb36(%511 : $Builtin.Word, %554 : $Builtin.Word) // id: %504
bb35: // Preds: bb33
%505 = apply %20(%511, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %507
retain_value %328 : $Optional<_ContiguousArrayStorage<Int>> // id: %506
cond_br %505, bb30, bb36(%511 : $Builtin.Word, %554 : $Builtin.Word) // id: %507
bb36(%508 : $Builtin.Word, %509 : $Builtin.Word): // Preds: bb29 bb34 bb35
%510 = apply %454(%508, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %511
%511 = tuple_extract %510 : $(Builtin.Word, Builtin.Int1), 0 // users: %503, %504, %505, %507, %527
%512 = enum_is_tag $Builtin.Int1, %329 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %513
%513 = apply %22(%512, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %514
cond_fail %513 : $Builtin.Int1 // id: %514
%515 = apply %36(%508, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %519
%516 = load %482 : $*Builtin.Word // user: %518
%517 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %518
%518 = apply %517(%508, %516) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %519
%519 = apply %53(%515, %518) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %520
%520 = apply %22(%519, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %521
cond_fail %520 : $Builtin.Int1 // id: %521
%522 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %523
%523 = apply %522(%508, %508) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %524
%524 = apply %22(%523, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %525
cond_fail %524 : $Builtin.Int1 // id: %525
%526 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %527
%527 = apply %526(%511, %508) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %528
%528 = apply %22(%527, %14) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %529
cond_fail %528 : $Builtin.Int1 // id: %529
%530 = apply %15<_ArrayBody>(%452) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %531
%531 = apply %454(%467, %530, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %532, %533
%532 = tuple_extract %531 : $(Builtin.Word, Builtin.Int1), 0 // user: %536
%533 = tuple_extract %531 : $(Builtin.Word, Builtin.Int1), 1 // user: %534
cond_fail %533 : $Builtin.Int1 // id: %534
%535 = apply %451<Int>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %536, %542
%536 = apply %454(%532, %535, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %537, %538
%537 = tuple_extract %536 : $(Builtin.Word, Builtin.Int1), 0 // user: %540
%538 = tuple_extract %536 : $(Builtin.Word, Builtin.Int1), 1 // user: %539
cond_fail %538 : $Builtin.Int1 // id: %539
%540 = apply %459(%537, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %541
%541 = tuple_extract %540 : $(Builtin.Word, Builtin.Int1), 0 // user: %545
%542 = apply %459(%535, %1, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %543
%543 = tuple_extract %542 : $(Builtin.Word, Builtin.Int1), 0 // user: %544
%544 = apply %464(%543, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %545
%545 = apply %466(%541, %544) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %546
%546 = apply %43(%545, %476, %44) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %547
%547 = tuple_extract %546 : $(Builtin.Word, Builtin.Int1), 0 // user: %548
%548 = index_raw_pointer %474 : $Builtin.RawPointer, %547 : $Builtin.Word // user: %549
%549 = pointer_to_address %548 : $Builtin.RawPointer to $*Int // user: %550
%550 = index_addr %549 : $*Int, %508 : $Builtin.Word // user: %551
%551 = load %550 : $*Int // user: %558
%552 = struct $Int (%509 : $Builtin.Word) // user: %492
%553 = apply %454(%509, %1, %14) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %554, %555
%554 = tuple_extract %553 : $(Builtin.Word, Builtin.Int1), 0 // users: %504, %507
%555 = tuple_extract %553 : $(Builtin.Word, Builtin.Int1), 1 // user: %556
cond_fail %555 : $Builtin.Int1 // id: %556
strong_retain %327 : $@callee_owned (Int) -> Bool // id: %557
%558 = apply %327(%551) : $@callee_owned (Int) -> Bool // user: %559
%559 = struct_extract %558 : $Bool, #Bool.value // user: %560
cond_br %559, bb31, bb33 // id: %560
}
// indexof.v1_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> Swift.Optional<A.Index>
sil indexof.v1_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> A.Index? : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Generator.Element : Equatable, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<C.Index>, @in C, @owned @callee_owned (@in C.Generator.Element) -> Bool) -> () {
bb0(%0 : $*Optional<C.Index>, %1 : $*C, %2 : $@callee_owned (@in C.Generator.Element) -> Bool):
// function_ref Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> Swift.Optional<A.Index>
%3 = function_ref Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> A.Index? : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0.Index>, @in τ_0_0, @in τ_0_0.Generator.Element) -> () // user: %19
%4 = alloc_stack $LazyForwardCollection<MapCollectionView<C, Bool>> // users: %14, %19, %24
// function_ref Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>>
%5 = function_ref Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>> : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible><τ_1_0> (@out LazyForwardCollection<MapCollectionView<τ_0_0, τ_1_0>>, @owned @callee_owned (@out τ_1_0, @in τ_0_0.Generator.Element) -> (), @in LazyForwardCollection<τ_0_0>) -> () // user: %14
%6 = alloc_stack $LazyForwardCollection<C> // users: %10, %14, %23
// function_ref Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A>
%7 = function_ref Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0) -> () // user: %10
%8 = alloc_stack $C // users: %9, %10, %22
copy_addr %1 to [initialization] %8#1 : $*C // id: %9
%10 = apply %7<C, C.Generator, C.Generator.Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%6#1, %8#1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0) -> ()
// function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool)
%11 = function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %12
%12 = partial_apply %11<C, C.Generator, C.Generator.Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%2) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %14
strong_retain %2 : $@callee_owned (@in C.Generator.Element) -> Bool // id: %13
%14 = apply %5<C, C.Generator, C.Generator.Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element, Bool>(%4#1, %12, %6#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible><τ_1_0> (@out LazyForwardCollection<MapCollectionView<τ_0_0, τ_1_0>>, @owned @callee_owned (@out τ_1_0, @in τ_0_0.Generator.Element) -> (), @in LazyForwardCollection<τ_0_0>) -> ()
%15 = alloc_stack $Bool // users: %18, %19, %21
%16 = integer_literal $Builtin.Int1, -1 // user: %17
%17 = struct $Bool (%16 : $Builtin.Int1) // user: %18
store %17 to %15#1 : $*Bool // id: %18
%19 = apply %3<LazyForwardCollection<MapCollectionView<C, Bool>>, MapSequenceGenerator<C.Generator, Bool>, Bool, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, Bool>(%0, %4#1, %15#1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0.Index>, @in τ_0_0, @in τ_0_0.Generator.Element) -> ()
strong_release %2 : $@callee_owned (@in C.Generator.Element) -> Bool // id: %20
dealloc_stack %15#0 : $*@local_storage Bool // id: %21
dealloc_stack %8#0 : $*@local_storage C // id: %22
dealloc_stack %6#0 : $*@local_storage LazyForwardCollection<C> // id: %23
dealloc_stack %4#0 : $*@local_storage LazyForwardCollection<MapCollectionView<C, Bool>> // id: %24
destroy_addr %1 : $*C // id: %25
%26 = tuple () // user: %27
return %26 : $() // id: %27
}
// Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> Swift.Optional<A.Index>
sil public_external Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> A.Index? : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Generator.Element : Equatable, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<C.Index>, @in C, @in C.Generator.Element) -> () {
bb0(%0 : $*Optional<C.Index>, %1 : $*C, %2 : $*C.Generator.Element):
%3 = alloc_stack $RangeGenerator<C.Index> // users: %10, %16, %38, %51, %55, %61
// function_ref Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A>
%4 = function_ref Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A> : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<τ_0_0>, @in Range<τ_0_0>) -> () // user: %10
%5 = alloc_stack $Range<C.Index> // users: %9, %10, %12
// function_ref Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index>
%6 = function_ref Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<τ_0_0.Index>, @in τ_0_0) -> () // user: %9
%7 = alloc_stack $C // users: %8, %9, %11
copy_addr %1 to [initialization] %7#1 : $*C // id: %8
%9 = apply %6<C, C.Generator, C.Generator.Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%5#1, %7#1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<τ_0_0.Index>, @in τ_0_0) -> ()
%10 = apply %4<C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex>(%3#1, %5#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<τ_0_0>, @in Range<τ_0_0>) -> ()
dealloc_stack %7#0 : $*@local_storage C // id: %11
dealloc_stack %5#0 : $*@local_storage Range<C.Index> // id: %12
%13 = alloc_stack $Optional<C.Index> // users: %16, %17, %21, %37, %50, %55, %56
// function_ref Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> Swift.Optional<A>
%14 = function_ref Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> A? : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0>, @inout RangeGenerator<τ_0_0>) -> () // users: %16, %55
// function_ref Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
%15 = function_ref Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // users: %17, %56
%16 = apply %14<C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex>(%13#1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0>, @inout RangeGenerator<τ_0_0>) -> ()
%17 = apply [transparent] %15<C.Index>(%13#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %18
cond_br %17, bb1, bb2 // id: %18
bb1: // Preds: bb0 bb4
%19 = alloc_stack $C.Index // users: %21, %26, %44, %48, %49, %53, %54
// function_ref Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
%20 = function_ref Swift._getOptionalValue <A>(A?) -> A : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> () // user: %21
%21 = apply [transparent] %20<C.Index>(%19#1, %13#1) : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> ()
%22 = metatype $@thick C.Generator.Element.Type // user: %31
%23 = witness_method $C.Generator.Element, #Equatable."=="!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %31
%24 = alloc_stack $C.Generator.Element // users: %28, %31, %35
%25 = alloc_stack $C.Index // users: %26, %28, %34
copy_addr %19#1 to [initialization] %25#1 : $*C.Index // id: %26
%27 = witness_method $C, #CollectionType.subscript!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> () // user: %28
%28 = apply %27<C, C.Generator, C.Generator.Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%24#1, %25#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> ()
%29 = alloc_stack $C.Generator.Element // users: %30, %31, %33
copy_addr %2 to [initialization] %29#1 : $*C.Generator.Element // id: %30
%31 = apply %23<C.Generator.Element>(%24#1, %29#1, %22) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %32
%32 = struct_extract %31 : $Bool, #Bool.value // user: %36
dealloc_stack %29#0 : $*@local_storage C.Generator.Element // id: %33
dealloc_stack %25#0 : $*@local_storage C.Index // id: %34
dealloc_stack %24#0 : $*@local_storage C.Generator.Element // id: %35
cond_br %32, bb3, bb4 // id: %36
bb2: // Preds: bb0 bb4
dealloc_stack %13#0 : $*@local_storage Optional<C.Index> // id: %37
destroy_addr %3#1 : $*RangeGenerator<C.Index> // id: %38
// function_ref Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
%39 = function_ref Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %41
%40 = metatype $@thin Optional<C.Index>.Type // user: %41
%41 = apply [transparent] %39<C.Index>(%0, %40) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
br bb5 // id: %42
bb3: // Preds: bb1
%43 = alloc_stack $C.Index // users: %44, %46, %47
copy_addr %19#1 to [initialization] %43#1 : $*C.Index // id: %44
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%45 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %46
%46 = apply [transparent] %45<C.Index>(%0, %43#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %43#0 : $*@local_storage C.Index // id: %47
destroy_addr %19#1 : $*C.Index // id: %48
dealloc_stack %19#0 : $*@local_storage C.Index // id: %49
dealloc_stack %13#0 : $*@local_storage Optional<C.Index> // id: %50
destroy_addr %3#1 : $*RangeGenerator<C.Index> // id: %51
br bb5 // id: %52
bb4: // Preds: bb1
destroy_addr %19#1 : $*C.Index // id: %53
dealloc_stack %19#0 : $*@local_storage C.Index // id: %54
%55 = apply %14<C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex>(%13#1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0>, @inout RangeGenerator<τ_0_0>) -> ()
%56 = apply [transparent] %15<C.Index>(%13#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %57
cond_br %56, bb1, bb2 // id: %57
bb5: // Preds: bb2 bb3
destroy_addr %2 : $*C.Generator.Element // id: %58
destroy_addr %1 : $*C // id: %59
%60 = tuple () // user: %62
dealloc_stack %3#0 : $*@local_storage RangeGenerator<C.Index> // id: %61
return %60 : $() // id: %62
}
// Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>>
sil public_external Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>> : $@cc(method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible><U> (@out LazyForwardCollection<MapCollectionView<S, U>>, @owned @callee_owned (@out U, @in S.Generator.Element) -> (), @in LazyForwardCollection<S>) -> () {
bb0(%0 : $*LazyForwardCollection<MapCollectionView<S, U>>, %1 : $@callee_owned (@out U, @in S.Generator.Element) -> (), %2 : $*LazyForwardCollection<S>):
// function_ref Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A>
%3 = function_ref Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0, @thin LazyForwardCollection<τ_0_0>.Type) -> () // user: %13
%4 = metatype $@thin LazyForwardCollection<MapCollectionView<S, U>>.Type // user: %13
%5 = alloc_stack $MapCollectionView<S, U> // users: %12, %13, %15
// function_ref Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B>
%6 = function_ref Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B> : $@thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<τ_0_0, τ_0_1>, @in τ_0_0, @owned @callee_owned (@out τ_0_1, @in τ_0_0.Generator.Element) -> (), @thin MapCollectionView<τ_0_0, τ_0_1>.Type) -> () // user: %12
%7 = metatype $@thin MapCollectionView<S, U>.Type // user: %12
%8 = struct_element_addr %2 : $*LazyForwardCollection<S>, #LazyForwardCollection._base // user: %10
%9 = alloc_stack $S // users: %10, %12, %14
copy_addr %8 to [initialization] %9#1 : $*S // id: %10
strong_retain %1 : $@callee_owned (@out U, @in S.Generator.Element) -> () // id: %11
%12 = apply %6<S, U, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%5#1, %9#1, %1, %7) : $@thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<τ_0_0, τ_0_1>, @in τ_0_0, @owned @callee_owned (@out τ_0_1, @in τ_0_0.Generator.Element) -> (), @thin MapCollectionView<τ_0_0, τ_0_1>.Type) -> ()
%13 = apply %3<MapCollectionView<S, U>, MapSequenceGenerator<S.Generator, U>, U, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, U>(%0, %5#1, %4) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0, @thin LazyForwardCollection<τ_0_0>.Type) -> ()
dealloc_stack %9#0 : $*@local_storage S // id: %14
dealloc_stack %5#0 : $*@local_storage MapCollectionView<S, U> // id: %15
destroy_addr %2 : $*LazyForwardCollection<S> // id: %16
strong_release %1 : $@callee_owned (@out U, @in S.Generator.Element) -> () // id: %17
%18 = tuple () // user: %19
return %18 : $() // id: %19
}
// Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A>
sil public_external Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A> : $@thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>, @in S) -> () {
bb0(%0 : $*LazyForwardCollection<S>, %1 : $*S):
// function_ref Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A>
%2 = function_ref Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0, @thin LazyForwardCollection<τ_0_0>.Type) -> () // user: %6
%3 = metatype $@thin LazyForwardCollection<S>.Type // user: %6
%4 = alloc_stack $S // users: %5, %6, %7
copy_addr %1 to [initialization] %4#1 : $*S // id: %5
%6 = apply %2<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %4#1, %3) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<τ_0_0>, @in τ_0_0, @thin LazyForwardCollection<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage S // id: %7
destroy_addr %1 : $*S // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool)
sil shared [transparent] reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool) : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Generator.Element : Equatable, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in C.Generator.Element, @owned @callee_owned (@in C.Generator.Element) -> Bool) -> () {
bb0(%0 : $*Bool, %1 : $*C.Generator.Element, %2 : $@callee_owned (@in C.Generator.Element) -> Bool):
%3 = apply %2(%1) : $@callee_owned (@in C.Generator.Element) -> Bool // user: %4
store %3 to %0 : $*Bool // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// Swift.Bool.init (Swift.Bool.Type)(_builtinBooleanLiteral : Builtin.Int1) -> Swift.Bool
sil public_external [transparent] Swift.Bool.init (Swift.Bool.Type)(_builtinBooleanLiteral : Builtin.Int1) -> Swift.Bool : $@thin (Builtin.Int1, @thin Bool.Type) -> Bool {
bb0(%0 : $Builtin.Int1, %1 : $@thin Bool.Type):
%2 = struct $Bool (%0 : $Builtin.Int1) // user: %3
return %2 : $Bool // id: %3
}
// indexof.v2_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> Swift.Optional<A.Index>
sil indexof.v2_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> A.Index? : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<C.Index>, @in C, @owned @callee_owned (@in C.Generator.Element) -> Bool) -> () {
bb0(%0 : $*Optional<C.Index>, %1 : $*C, %2 : $@callee_owned (@in C.Generator.Element) -> Bool):
%3 = alloc_stack $EnumerateGenerator<C.Generator> // var $generator // users: %10, %16, %47, %52, %56, %64
// function_ref Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator>
%4 = function_ref Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator> : $@cc(method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateGenerator<τ_0_0.Generator>, @in EnumerateSequence<τ_0_0>) -> () // user: %10
%5 = alloc_stack $EnumerateSequence<C> // users: %9, %10, %12
// function_ref Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A>
%6 = function_ref Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A> : $@thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateSequence<τ_0_0>, @in τ_0_0) -> () // user: %9
%7 = alloc_stack $C // users: %8, %9, %11
copy_addr %1 to [initialization] %7#1 : $*C // id: %8
%9 = apply %6<C, C.Generator, C.Generator.Element>(%5#1, %7#1) : $@thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateSequence<τ_0_0>, @in τ_0_0) -> ()
%10 = apply %4<C, C.Generator, C.Generator.Element>(%3#1, %5#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateGenerator<τ_0_0.Generator>, @in EnumerateSequence<τ_0_0>) -> ()
dealloc_stack %7#0 : $*@local_storage C // id: %11
dealloc_stack %5#0 : $*@local_storage EnumerateSequence<C> // id: %12
%13 = alloc_stack $Optional<(index: Int, element: C.Generator.Element)> // users: %16, %17, %22, %46, %52, %53, %55
// function_ref Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> Swift.Optional<(index : Swift.Int, element : A.Element)>
%14 = function_ref Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> (index : Swift.Int, element : A.Element)? : $@cc(method) @thin <τ_0_0 where τ_0_0 : GeneratorType> (@out Optional<(index: Int, element: τ_0_0.Element)>, @inout EnumerateGenerator<τ_0_0>) -> () // users: %16, %52
// function_ref Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
%15 = function_ref Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // users: %17, %53
%16 = apply %14<C.Generator, C.Generator.Element>(%13#1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : GeneratorType> (@out Optional<(index: Int, element: τ_0_0.Element)>, @inout EnumerateGenerator<τ_0_0>) -> ()
%17 = apply [transparent] %15<(index: Int, element: C.Generator.Element)>(%13#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %18
cond_br %17, bb1, bb7 // id: %18
bb1: // Preds: bb0 bb6
%19 = alloc_stack $C.Generator.Element // let element // users: %26, %28, %44, %45, %50, %51
// function_ref Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
%20 = function_ref Swift._getOptionalValue <A>(A?) -> A : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> () // user: %22
%21 = alloc_stack $(index: Int, element: C.Generator.Element) // users: %22, %23, %25, %43, %49
%22 = apply [transparent] %20<(index: Int, element: C.Generator.Element)>(%21#1, %13#1) : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> ()
%23 = tuple_element_addr %21#1 : $*(index: Int, element: C.Generator.Element), 0 // user: %24
%24 = load %23 : $*Int // user: %36
%25 = tuple_element_addr %21#1 : $*(index: Int, element: C.Generator.Element), 1 // user: %26
copy_addr [take] %25 to [initialization] %19#1 : $*C.Generator.Element // id: %26
%27 = alloc_stack $C.Generator.Element // users: %28, %30, %32
copy_addr %19#1 to [initialization] %27#1 : $*C.Generator.Element // id: %28
strong_retain %2 : $@callee_owned (@in C.Generator.Element) -> Bool // id: %29
%30 = apply %2(%27#1) : $@callee_owned (@in C.Generator.Element) -> Bool // user: %31
%31 = struct_extract %30 : $Bool, #Bool.value // user: %33
dealloc_stack %27#0 : $*@local_storage C.Generator.Element // id: %32
cond_br %31, bb2, bb6 // id: %33
bb2: // Preds: bb1
%34 = init_enum_data_addr %0 : $*Optional<C.Index>, #Optional.Some!enumelt.1 // user: %37
%35 = alloc_stack $Int // users: %36, %37, %42
store %24 to %35#1 : $*Int // id: %36
checked_cast_addr_br take_always Int in %35#1 : $*Int to C.Index in %34 : $*C.Index, bb3, bb4 // id: %37
bb3: // Preds: bb2
inject_enum_addr %0 : $*Optional<C.Index>, #Optional.Some!enumelt.1 // id: %38
br bb5 // id: %39
bb4: // Preds: bb2
inject_enum_addr %0 : $*Optional<C.Index>, #Optional.None!enumelt // id: %40
br bb5 // id: %41
bb5: // Preds: bb3 bb4
dealloc_stack %35#0 : $*@local_storage Int // id: %42
dealloc_stack %21#0 : $*@local_storage (index: Int, element: C.Generator.Element) // id: %43
destroy_addr %19#1 : $*C.Generator.Element // id: %44
dealloc_stack %19#0 : $*@local_storage C.Generator.Element // id: %45
dealloc_stack %13#0 : $*@local_storage Optional<(index: Int, element: C.Generator.Element)> // id: %46
destroy_addr %3#1 : $*EnumerateGenerator<C.Generator> // id: %47
br bb8 // id: %48
bb6: // Preds: bb1
dealloc_stack %21#0 : $*@local_storage (index: Int, element: C.Generator.Element) // id: %49
destroy_addr %19#1 : $*C.Generator.Element // id: %50
dealloc_stack %19#0 : $*@local_storage C.Generator.Element // id: %51
%52 = apply %14<C.Generator, C.Generator.Element>(%13#1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : GeneratorType> (@out Optional<(index: Int, element: τ_0_0.Element)>, @inout EnumerateGenerator<τ_0_0>) -> ()
%53 = apply [transparent] %15<(index: Int, element: C.Generator.Element)>(%13#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %54
cond_br %53, bb1, bb7 // id: %54
bb7: // Preds: bb0 bb6
dealloc_stack %13#0 : $*@local_storage Optional<(index: Int, element: C.Generator.Element)> // id: %55
destroy_addr %3#1 : $*EnumerateGenerator<C.Generator> // id: %56
// function_ref Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
%57 = function_ref Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %59
%58 = metatype $@thin Optional<C.Index>.Type // user: %59
%59 = apply [transparent] %57<C.Index>(%0, %58) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
br bb8 // id: %60
bb8: // Preds: bb5 bb7
strong_release %2 : $@callee_owned (@in C.Generator.Element) -> Bool // id: %61
destroy_addr %1 : $*C // id: %62
%63 = tuple () // user: %65
dealloc_stack %3#0 : $*@local_storage EnumerateGenerator<C.Generator> // id: %64
return %63 : $() // id: %65
}
// Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator>
sil public_external Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator> : $@cc(method) @thin <Base where Base : SequenceType, Base.Generator : GeneratorType> (@out EnumerateGenerator<Base.Generator>, @in EnumerateSequence<Base>) -> () {
bb0(%0 : $*EnumerateGenerator<Base.Generator>, %1 : $*EnumerateSequence<Base>):
// function_ref Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A>
%2 = function_ref Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A> : $@thin <τ_0_0 where τ_0_0 : GeneratorType> (@out EnumerateGenerator<τ_0_0>, @in τ_0_0, @thin EnumerateGenerator<τ_0_0>.Type) -> () // user: %8
%3 = metatype $@thin EnumerateGenerator<Base.Generator>.Type // user: %8
%4 = alloc_stack $Base.Generator // users: %7, %8, %9
%5 = struct_element_addr %1 : $*EnumerateSequence<Base>, #EnumerateSequence.base // user: %7
%6 = witness_method $Base, #SequenceType.generate!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out τ_0_0.Generator, @inout τ_0_0) -> () // user: %7
%7 = apply %6<Base, Base.Generator, Base.Generator.Element>(%4#1, %5) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out τ_0_0.Generator, @inout τ_0_0) -> ()
%8 = apply %2<Base.Generator, Base.Generator.Element>(%0, %4#1, %3) : $@thin <τ_0_0 where τ_0_0 : GeneratorType> (@out EnumerateGenerator<τ_0_0>, @in τ_0_0, @thin EnumerateGenerator<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage Base.Generator // id: %9
destroy_addr %1 : $*EnumerateSequence<Base> // id: %10
%11 = tuple () // user: %12
return %11 : $() // id: %12
}
// Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A>
sil public_external Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A> : $@thin <Seq where Seq : SequenceType, Seq.Generator : GeneratorType> (@out EnumerateSequence<Seq>, @in Seq) -> () {
bb0(%0 : $*EnumerateSequence<Seq>, %1 : $*Seq):
// function_ref Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A>
%2 = function_ref Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A> : $@thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateSequence<τ_0_0>, @in τ_0_0, @thin EnumerateSequence<τ_0_0>.Type) -> () // user: %6
%3 = metatype $@thin EnumerateSequence<Seq>.Type // user: %6
%4 = alloc_stack $Seq // users: %5, %6, %7
copy_addr %1 to [initialization] %4#1 : $*Seq // id: %5
%6 = apply %2<Seq, Seq.Generator, Seq.Generator.Element>(%0, %4#1, %3) : $@thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@out EnumerateSequence<τ_0_0>, @in τ_0_0, @thin EnumerateSequence<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage Seq // id: %7
destroy_addr %1 : $*Seq // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> Swift.Optional<(index : Swift.Int, element : A.Element)>
sil public_external Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> (index : Swift.Int, element : A.Element)? : $@cc(method) @thin <Base where Base : GeneratorType> (@out Optional<(index: Int, element: Base.Element)>, @inout EnumerateGenerator<Base>) -> () {
bb0(%0 : $*Optional<(index: Int, element: Base.Element)>, %1 : $*EnumerateGenerator<Base>):
%2 = alloc_stack $Optional<Base.Element> // users: %5, %8, %37, %38, %43, %45
%3 = struct_element_addr %1 : $*EnumerateGenerator<Base>, #EnumerateGenerator.base // user: %5
%4 = witness_method $Base, #GeneratorType.next!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : GeneratorType> (@out Optional<τ_0_0.Element>, @inout τ_0_0) -> () // user: %5
%5 = apply %4<Base, Base.Element>(%2#1, %3) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : GeneratorType> (@out Optional<τ_0_0.Element>, @inout τ_0_0) -> ()
// function_ref Swift.== infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%6 = function_ref Swift.== infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %10
%7 = alloc_stack $Optional<Base.Element> // users: %8, %10, %12
copy_addr %2#1 to [initialization] %7#1 : $*Optional<Base.Element> // id: %8
%9 = struct $_OptionalNilComparisonType () // user: %10
%10 = apply %6<Base.Element>(%7#1, %9) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %11
%11 = struct_extract %10 : $Bool, #Bool.value // user: %13
dealloc_stack %7#0 : $*@local_storage Optional<Base.Element> // id: %12
cond_br %11, bb1, bb2 // id: %13
bb1: // Preds: bb0
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%14 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %16
%15 = metatype $@thin Optional<(index: Int, element: Base.Element)>.Type // user: %16
%16 = apply [transparent] %14<(index: Int, element: Base.Element)>(%0, %15) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
br bb3 // id: %17
bb2: // Preds: bb0
// function_ref Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
%18 = function_ref Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> () // user: %40
%19 = metatype $@thin Optional<(index: Int, element: Base.Element)>.Type // user: %40
%20 = alloc_stack $(index: Int, element: Base.Element) // users: %21, %22, %40, %41
%21 = tuple_element_addr %20#1 : $*(index: Int, element: Base.Element), 0 // user: %35
%22 = tuple_element_addr %20#1 : $*(index: Int, element: Base.Element), 1 // user: %39
%23 = struct_element_addr %1 : $*EnumerateGenerator<Base>, #EnumerateGenerator.count // users: %24, %34
%24 = load %23 : $*Int // users: %27, %35
%25 = integer_literal $Builtin.Word, 1 // user: %29
%26 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %29
%27 = struct_extract %24 : $Int, #Int.value // user: %29
%28 = integer_literal $Builtin.Int1, -1 // user: %29
%29 = apply %26(%27, %25, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %30, %31
%30 = tuple_extract %29 : $(Builtin.Word, Builtin.Int1), 0 // user: %33
%31 = tuple_extract %29 : $(Builtin.Word, Builtin.Int1), 1 // user: %32
cond_fail %31 : $Builtin.Int1 // id: %32
%33 = struct $Int (%30 : $Builtin.Word) // user: %34
store %33 to %23 : $*Int // id: %34
store %24 to %21 : $*Int // id: %35
// function_ref Swift._preconditionOptionalHasValue <A>(inout Swift.Optional<A>) -> ()
%36 = function_ref Swift._preconditionOptionalHasValue <A>(inout A?) -> () : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> () // user: %37
%37 = apply [transparent] %36<Base.Element>(%2#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> ()
%38 = unchecked_take_enum_data_addr %2#1 : $*Optional<Base.Element>, #Optional.Some!enumelt.1 // user: %39
copy_addr %38 to [initialization] %22 : $*Base.Element // id: %39
%40 = apply [transparent] %18<(index: Int, element: Base.Element)>(%0, %20#1, %19) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> ()
dealloc_stack %20#0 : $*@local_storage (index: Int, element: Base.Element) // id: %41
br bb3 // id: %42
bb3: // Preds: bb1 bb2
destroy_addr %2#1 : $*Optional<Base.Element> // id: %43
%44 = tuple () // user: %46
dealloc_stack %2#0 : $*@local_storage Optional<Base.Element> // id: %45
return %44 : $() // id: %46
}
// Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
sil public_external [transparent] Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin <T> (@inout Optional<T>) -> Builtin.Int1 {
bb0(%0 : $*Optional<T>):
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%1 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %5
%2 = alloc_stack $Optional<T> // users: %3, %5, %7
copy_addr %0 to [initialization] %2#1 : $*Optional<T> // id: %3
%4 = struct $_OptionalNilComparisonType () // user: %5
%5 = apply %1<T>(%2#1, %4) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %6
%6 = struct_extract %5 : $Bool, #Bool.value // user: %8
dealloc_stack %2#0 : $*@local_storage Optional<T> // id: %7
return %6 : $Builtin.Int1 // id: %8
}
// Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
sil public_external [transparent] Swift._getOptionalValue <A>(A?) -> A : $@thin <T> (@out T, @in Optional<T>) -> () {
bb0(%0 : $*T, %1 : $*Optional<T>):
%2 = alloc_stack $T // users: %7, %8, %12
%3 = alloc_stack $Optional<T> // users: %4, %5, %6, %9, %14
copy_addr %1 to [initialization] %3#1 : $*Optional<T> // id: %4
switch_enum_addr %3#1 : $*Optional<T>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %5
bb1: // Preds: bb0
%6 = unchecked_take_enum_data_addr %3#1 : $*Optional<T>, #Optional.Some!enumelt.1 // user: %7
copy_addr [take] %6 to [initialization] %2#1 : $*T // id: %7
copy_addr [take] %2#1 to [initialization] %0 : $*T // id: %8
dealloc_stack %3#0 : $*@local_storage Optional<T> // id: %9
destroy_addr %1 : $*Optional<T> // id: %10
%11 = tuple () // user: %13
dealloc_stack %2#0 : $*@local_storage T // id: %12
return %11 : $() // id: %13
bb2: // Preds: bb0
dealloc_stack %3#0 : $*@local_storage Optional<T> // id: %14
%15 = integer_literal $Builtin.Int1, -1 // user: %16
cond_fail %15 : $Builtin.Int1 // id: %16
unreachable // id: %17
}
// Swift.Bool._getBuiltinLogicValue (Swift.Bool)() -> Builtin.Int1
sil public_external [transparent] Swift.Bool._getBuiltinLogicValue (Swift.Bool)() -> Builtin.Int1 : $@cc(method) @thin (Bool) -> Builtin.Int1 {
bb0(%0 : $Bool):
%1 = struct_extract %0 : $Bool, #Bool.value // user: %2
return %1 : $Builtin.Int1 // id: %2
}
// Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
sil public_external [transparent] Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin <T> (@out Optional<T>, @thin Optional<T>.Type) -> () {
bb0(%0 : $*Optional<T>, %1 : $@thin Optional<T>.Type):
%2 = alloc_stack $Optional<T> // users: %7, %9, %11
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%3 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %6
%4 = metatype $@thin Optional<T>.Type // user: %6
%5 = alloc_stack $Optional<T> // users: %6, %7, %8
%6 = apply [transparent] %3<T>(%5#1, %4) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
copy_addr [take] %5#1 to [initialization] %2#1 : $*Optional<T> // id: %7
dealloc_stack %5#0 : $*@local_storage Optional<T> // id: %8
copy_addr [take] %2#1 to [initialization] %0 : $*Optional<T> // id: %9
%10 = tuple () // user: %12
dealloc_stack %2#0 : $*@local_storage Optional<T> // id: %11
return %10 : $() // id: %12
}
// Swift.Array.init <A>(Swift.Array<A>.Type)(arrayLiteral : Swift.Array<A>...) -> Swift.Array<A>
sil public_external Swift.Array.init <A>([A].Type)(arrayLiteral : [A]...) -> [A] : $@thin <T> (@owned Array<T>, @thin Array<T>.Type) -> @owned Array<T> {
bb0(%0 : $Array<T>, %1 : $@thin Array<T>.Type):
return %0 : $Array<T> // id: %2
}
// Swift.Int.init (Swift.Int.Type)(_builtinIntegerLiteral : Builtin.Int2048) -> Swift.Int
sil public_external [transparent] Swift.Int.init (Swift.Int.Type)(_builtinIntegerLiteral : Builtin.Int2048) -> Swift.Int : $@thin (Builtin.Int2048, @thin Int.Type) -> Int {
bb0(%0 : $Builtin.Int2048, %1 : $@thin Int.Type):
%2 = builtin_function_ref "s_to_s_checked_trunc_Int2048_Word" : $@thin (Builtin.Int2048) -> (Builtin.Word, Builtin.Int1) // user: %3
%3 = apply %2(%0) : $@thin (Builtin.Int2048) -> (Builtin.Word, Builtin.Int1) // user: %4
%4 = tuple_extract %3 : $(Builtin.Word, Builtin.Int1), 0 // user: %5
%5 = struct $Int (%4 : $Builtin.Word) // user: %6
return %5 : $Int // id: %6
}
// Swift.Array.convertFromHeapArray <A>(Swift.Array<A>.Type)(Builtin.RawPointer, owner : Builtin.NativeObject, count : Builtin.Word) -> Swift.Array<A>
sil public_external [readonly] Swift.Array.convertFromHeapArray <A>([A].Type)(Builtin.RawPointer, owner : Builtin.NativeObject, count : Builtin.Word) -> [A] : $@thin <T> (Builtin.RawPointer, @owned Builtin.NativeObject, Builtin.Word, @thin Array<T>.Type) -> @owned Array<T> {
bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.NativeObject, %2 : $Builtin.Word, %3 : $@thin Array<T>.Type):
// function_ref Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A>
%4 = function_ref Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A> : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int, @thin UnsafeBufferPointer<τ_0_0>.Type) -> UnsafeBufferPointer<τ_0_0> // user: %31
%5 = metatype $@thin UnsafeBufferPointer<T>.Type // user: %31
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%6 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %11
%7 = alloc_stack $Builtin.RawPointer // users: %8, %11, %35
store %0 to %7#1 : $*Builtin.RawPointer // id: %8
%9 = metatype $@thick UnsafeMutablePointer<T>.Type // user: %11
%10 = alloc_stack $UnsafeMutablePointer<T> // users: %11, %12, %34
%11 = apply [transparent] %6<Builtin.RawPointer, UnsafeMutablePointer<T>>(%10#1, %7#1, %9) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%12 = load %10#1 : $*UnsafeMutablePointer<T> // user: %14
%13 = alloc_stack $UnsafeMutablePointer<T> // users: %14, %17, %33
store %12 to %13#1 : $*UnsafeMutablePointer<T> // id: %14
// function_ref Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B
%15 = function_ref Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _PointerType, τ_0_1 : _PointerType> (@out τ_0_1, @in τ_0_0) -> () // user: %17
%16 = alloc_stack $UnsafePointer<T> // users: %17, %18, %32
%17 = apply [transparent] %15<UnsafeMutablePointer<T>, UnsafePointer<T>>(%16#1, %13#1) : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _PointerType, τ_0_1 : _PointerType> (@out τ_0_1, @in τ_0_0) -> ()
%18 = load %16#1 : $*UnsafePointer<T> // user: %31
%19 = integer_literal $Builtin.Int1, -1 // user: %28
%20 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %22, %24
%21 = metatype $@thick Builtin.Word.Type // user: %22
%22 = apply %20<Builtin.Word>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%23 = metatype $@thick Int.Type // user: %24
%24 = apply %20<Int>(%23) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%25 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %26
%26 = apply %25(%22, %24) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %28
%27 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %28
%28 = apply %27(%26, %19) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %29
cond_fail %28 : $Builtin.Int1 // id: %29
%30 = unchecked_trivial_bit_cast %2 : $Builtin.Word to $Int // user: %31
%31 = apply %4<T>(%18, %30, %5) : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int, @thin UnsafeBufferPointer<τ_0_0>.Type) -> UnsafeBufferPointer<τ_0_0> // user: %39
dealloc_stack %16#0 : $*@local_storage UnsafePointer<T> // id: %32
dealloc_stack %13#0 : $*@local_storage UnsafeMutablePointer<T> // id: %33
dealloc_stack %10#0 : $*@local_storage UnsafeMutablePointer<T> // id: %34
dealloc_stack %7#0 : $*@local_storage Builtin.RawPointer // id: %35
// function_ref Swift.Array.init <A>(Swift.Array<A>.Type)<B : Swift.SequenceType>(B) -> Swift.Array<A>
%36 = function_ref Swift.Array.init <A>([A].Type)<B : Swift.SequenceType>(B) -> [A] : $@thin <τ_0_0><τ_1_0 where τ_1_0 : SequenceType, τ_1_0.Generator : GeneratorType, τ_1_0.Generator.Element == τ_0_0> (@in τ_1_0, @thin Array<τ_0_0>.Type) -> @owned Array<τ_0_0> // user: %40
%37 = metatype $@thin Array<T>.Type // user: %40
%38 = alloc_stack $UnsafeBufferPointer<T> // users: %39, %40, %41
store %31 to %38#1 : $*UnsafeBufferPointer<T> // id: %39
%40 = apply %36<T, UnsafeBufferPointer<T>, UnsafeBufferPointerGenerator<T>>(%38#1, %37) : $@thin <τ_0_0><τ_1_0 where τ_1_0 : SequenceType, τ_1_0.Generator : GeneratorType, τ_1_0.Generator.Element == τ_0_0> (@in τ_1_0, @thin Array<τ_0_0>.Type) -> @owned Array<τ_0_0> // user: %48
dealloc_stack %38#0 : $*@local_storage UnsafeBufferPointer<T> // id: %41
%42 = alloc_stack $Builtin.NativeObject // users: %43, %44, %45, %47
store %1 to %42#1 : $*Builtin.NativeObject // id: %43
fix_lifetime %42#1 : $*Builtin.NativeObject // id: %44
%45 = load %42#1 : $*Builtin.NativeObject // user: %46
strong_release %45 : $Builtin.NativeObject // id: %46
dealloc_stack %42#0 : $*@local_storage Builtin.NativeObject // id: %47
return %40 : $Array<T> // id: %48
}
// indexof.(closure #1)
sil shared indexof.(closure #1) : $@thin (Int) -> Bool {
bb0(%0 : $Int):
%1 = integer_literal $Builtin.Word, 1 // user: %4
%2 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %4
%3 = struct_extract %0 : $Int, #Int.value // user: %4
%4 = apply %2(%3, %1) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %5
%5 = struct $Bool (%4 : $Builtin.Int1) // user: %6
return %5 : $Bool // id: %6
}
// Swift.== infix (Swift.Int, Swift.Int) -> Swift.Bool
sil public_external [transparent] Swift.== infix (Swift.Int, Swift.Int) -> Swift.Bool : $@thin (Int, Int) -> Bool {
bb0(%0 : $Int, %1 : $Int):
%2 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %5
%3 = struct_extract %0 : $Int, #Int.value // user: %5
%4 = struct_extract %1 : $Int, #Int.value // user: %5
%5 = apply %2(%3, %4) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %6
%6 = struct $Bool (%5 : $Builtin.Int1) // user: %7
return %6 : $Bool // id: %7
}
// reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool) with unmangled suffix "_constprop0"
sil shared [transparent] reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool) with unmangled suffix "_constprop0" : $@thin (@in Int) -> Bool {
bb0(%0 : $*Int):
%1 = struct_element_addr %0 : $*Int, #Int.value // user: %2
%2 = load %1 : $*Builtin.Word // user: %5
%3 = integer_literal $Builtin.Word, 1 // user: %5
%4 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %5
%5 = apply %4(%2, %3) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %6
%6 = struct $Bool (%5 : $Builtin.Int1) // user: %7
return %6 : $Bool // id: %7
}
// reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool)
sil shared [transparent] reabstraction thunk helper from @callee_owned (@unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_owned (@in Swift.Int) -> (@unowned Swift.Bool) : $@thin (@in Int, @owned @callee_owned (Int) -> Bool) -> Bool {
bb0(%0 : $*Int, %1 : $@callee_owned (Int) -> Bool):
%2 = load %0 : $*Int // user: %3
%3 = apply %1(%2) : $@callee_owned (Int) -> Bool // user: %4
return %3 : $Bool // id: %4
}
// Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
sil public_external Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <T> (@in Optional<T>, _OptionalNilComparisonType) -> Bool {
bb0(%0 : $*Optional<T>, %1 : $_OptionalNilComparisonType):
%2 = alloc_stack $Optional<T> // users: %3, %4, %5, %13
copy_addr %0 to [initialization] %2#1 : $*Optional<T> // id: %3
switch_enum_addr %2#1 : $*Optional<T>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %4
bb1: // Preds: bb0
%5 = unchecked_take_enum_data_addr %2#1 : $*Optional<T>, #Optional.Some!enumelt.1 // user: %6
destroy_addr %5 : $*T // id: %6
%7 = integer_literal $Builtin.Int1, -1 // user: %8
br bb3(%7 : $Builtin.Int1) // id: %8
bb2: // Preds: bb0
%9 = integer_literal $Builtin.Int1, 0 // user: %10
br bb3(%9 : $Builtin.Int1) // id: %10
bb3(%11 : $Builtin.Int1): // Preds: bb1 bb2
%12 = struct $Bool (%11 : $Builtin.Int1) // user: %15
dealloc_stack %2#0 : $*@local_storage Optional<T> // id: %13
destroy_addr %0 : $*Optional<T> // id: %14
return %12 : $Bool // id: %15
}
// Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
sil public_external [transparent] Swift.Optional.None <A>(A?.Type) -> A? : $@thin <T> (@out Optional<T>, @thin Optional<T>.Type) -> () {
bb0(%0 : $*Optional<T>, %1 : $@thin Optional<T>.Type):
inject_enum_addr %0 : $*Optional<T>, #Optional.None!enumelt // id: %2
%3 = tuple () // user: %4
return %3 : $() // id: %4
}
// Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A>
sil public_external Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A> : $@thin <T> (UnsafePointer<T>, Int, @thin UnsafeBufferPointer<T>.Type) -> UnsafeBufferPointer<T> {
bb0(%0 : $UnsafePointer<T>, %1 : $Int, %2 : $@thin UnsafeBufferPointer<T>.Type):
%3 = integer_literal $Builtin.Int1, -1 // user: %9
%4 = integer_literal $Builtin.Word, 0 // user: %7
%5 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %7
%6 = struct_extract %1 : $Int, #Int.value // user: %7
%7 = apply %5(%6, %4) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%8 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
%9 = apply %8(%7, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %10
cond_fail %9 : $Builtin.Int1 // id: %10
// function_ref Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A>
%11 = function_ref Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A> : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int) -> UnsafePointer<τ_0_0> // user: %12
%12 = apply [transparent] %11<T>(%0, %1) : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int) -> UnsafePointer<τ_0_0> // user: %13
%13 = struct $UnsafeBufferPointer<T> (%0 : $UnsafePointer<T>, %12 : $UnsafePointer<T>) // user: %14
return %13 : $UnsafeBufferPointer<T> // id: %14
}
// Swift.unsafeBitCast <A, B>(A, B.Type) -> B
sil public_external [transparent] Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <T, U> (@out U, @in T, @thick U.Type) -> () {
bb0(%0 : $*U, %1 : $*T, %2 : $@thick U.Type):
%3 = alloc_stack $T // users: %4, %20, %24, %26
copy_addr [take] %1 to [initialization] %3#1 : $*T // id: %4
%5 = integer_literal $Builtin.Int1, -1 // user: %16
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%6 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %8, %10
%7 = metatype $@thick T.Type // user: %8
%8 = apply [transparent] %6<T>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %12
%9 = metatype $@thick U.Type // user: %10
%10 = apply [transparent] %6<U>(%9) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%11 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %14
%12 = struct_extract %8 : $Int, #Int.value // user: %14
%13 = struct_extract %10 : $Int, #Int.value // user: %14
%14 = apply %11(%12, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
%15 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %16
%16 = apply %15(%14, %5) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
cond_fail %16 : $Builtin.Int1 // id: %17
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%18 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %21
%19 = metatype $@thin UnsafeMutablePointer<U>.Type // user: %21
%20 = address_to_pointer %3#1 : $*T to $Builtin.RawPointer // user: %21
%21 = apply [transparent] %18<U>(%20, %19) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %23
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%22 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %23
%23 = apply [transparent] %22<U>(%0, %21) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
destroy_addr %3#1 : $*T // id: %24
%25 = tuple () // user: %27
dealloc_stack %3#0 : $*@local_storage T // id: %26
return %25 : $() // id: %27
}
// Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B
sil public_external [transparent] Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B : $@thin <FromPointer, ToPointer where FromPointer : _PointerType, ToPointer : _PointerType> (@out ToPointer, @in FromPointer) -> () {
bb0(%0 : $*ToPointer, %1 : $*FromPointer):
%2 = metatype $@thick ToPointer.Type // user: %6
%3 = witness_method $ToPointer, #_PointerType.init!allocator.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _PointerType> (@out τ_0_0, Builtin.RawPointer, @thick τ_0_0.Type) -> () // user: %6
%4 = witness_method $FromPointer, #_PointerType.value!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _PointerType> (@inout τ_0_0) -> Builtin.RawPointer // user: %5
%5 = apply %4<FromPointer>(%1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _PointerType> (@inout τ_0_0) -> Builtin.RawPointer // user: %6
%6 = apply %3<ToPointer>(%0, %5, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _PointerType> (@out τ_0_0, Builtin.RawPointer, @thick τ_0_0.Type) -> ()
destroy_addr %1 : $*FromPointer // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// Swift.Array.init <A>(Swift.Array<A>.Type)<B : Swift.SequenceType>(B) -> Swift.Array<A>
sil public_external Swift.Array.init <A>([A].Type)<B : Swift.SequenceType>(B) -> [A] : $@thin <T><S where S : SequenceType, S.Generator : GeneratorType, S.Generator.Element == T> (@in S, @thin Array<T>.Type) -> @owned Array<T> {
bb0(%0 : $*S, %1 : $@thin Array<T>.Type):
// function_ref Swift.Array.init <A>(Swift.Array<A>.Type)(Swift._ArrayBuffer<A>) -> Swift.Array<A>
%2 = function_ref Swift.Array.init <A>([A].Type)(Swift._ArrayBuffer<A>) -> [A] : $@thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>, @thin Array<τ_0_0>.Type) -> @owned Array<τ_0_0> // user: %13
%3 = metatype $@thin Array<T>.Type // user: %13
// function_ref Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A>
%4 = function_ref Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A> : $@thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, @thin _ArrayBuffer<τ_0_0>.Type) -> @owned _ArrayBuffer<τ_0_0> // user: %12
%5 = metatype $@thin _ArrayBuffer<T>.Type // user: %12
%6 = metatype $@thick S.Type // user: %11
%7 = witness_method $S, #SequenceType."~>"!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@in τ_0_0, _CopyToNativeArrayBuffer, @thick τ_0_0.Type) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %11
%8 = alloc_stack $S // users: %9, %11, %14
copy_addr %0 to [initialization] %8#1 : $*S // id: %9
%10 = struct $_CopyToNativeArrayBuffer () // user: %11
%11 = apply %7<S, S.Generator, T>(%8#1, %10, %6) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : SequenceType, τ_0_0.Generator : GeneratorType> (@in τ_0_0, _CopyToNativeArrayBuffer, @thick τ_0_0.Type) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %12
%12 = apply %4<T>(%11, %5) : $@thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, @thin _ArrayBuffer<τ_0_0>.Type) -> @owned _ArrayBuffer<τ_0_0> // user: %13
%13 = apply %2<T>(%12, %3) : $@thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>, @thin Array<τ_0_0>.Type) -> @owned Array<τ_0_0> // user: %16
dealloc_stack %8#0 : $*@local_storage S // id: %14
destroy_addr %0 : $*S // id: %15
return %13 : $Array<T> // id: %16
}
// Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A>
sil public_external [transparent] Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A> : $@thin <T> (UnsafePointer<T>, Int) -> UnsafePointer<T> {
bb0(%0 : $UnsafePointer<T>, %1 : $Int):
// function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A>
%2 = function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %15
%3 = metatype $@thin UnsafePointer<T>.Type // user: %15
%4 = struct_extract %0 : $UnsafePointer<T>, #UnsafePointer.value // user: %14
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%5 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %7
%6 = metatype $@thick T.Type // user: %7
%7 = apply [transparent] %5<T>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %9
%8 = struct_extract %1 : $Int, #Int.value // user: %12
%9 = struct_extract %7 : $Int, #Int.value // user: %12
%10 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %12
%11 = integer_literal $Builtin.Int1, 0 // user: %12
%12 = apply %10(%8, %9, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %13
%13 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 0 // user: %14
%14 = index_raw_pointer %4 : $Builtin.RawPointer, %13 : $Builtin.Word // user: %15
%15 = apply [transparent] %2<T>(%14, %3) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %16
return %15 : $UnsafePointer<T> // id: %16
}
// Swift.sizeof <A>(A.Type) -> Swift.Int
sil public_external [transparent] Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <T> (@thick T.Type) -> Int {
bb0(%0 : $@thick T.Type):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <T> (Builtin.RawPointer, @thin UnsafeMutablePointer<T>.Type) -> UnsafeMutablePointer<T> {
bb0(%0 : $Builtin.RawPointer, %1 : $@thin UnsafeMutablePointer<T>.Type):
%2 = struct $UnsafeMutablePointer<T> (%0 : $Builtin.RawPointer) // user: %3
return %2 : $UnsafeMutablePointer<T> // id: %3
}
// Swift.UnsafeMutablePointer.memory.getter : A
sil public_external [transparent] Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <T> (@out T, UnsafeMutablePointer<T>) -> () {
bb0(%0 : $*T, %1 : $UnsafeMutablePointer<T>):
%2 = struct_extract %1 : $UnsafeMutablePointer<T>, #UnsafeMutablePointer.value // user: %3
%3 = pointer_to_address %2 : $Builtin.RawPointer to $*T // user: %4
copy_addr %3 to [initialization] %0 : $*T // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// Swift.Array.init <A>(Swift.Array<A>.Type)(Swift._ArrayBuffer<A>) -> Swift.Array<A>
sil public_external Swift.Array.init <A>([A].Type)(Swift._ArrayBuffer<A>) -> [A] : $@thin <T> (@owned _ArrayBuffer<T>, @thin Array<T>.Type) -> @owned Array<T> {
bb0(%0 : $_ArrayBuffer<T>, %1 : $@thin Array<T>.Type):
%2 = struct $Array<T> (%0 : $_ArrayBuffer<T>) // user: %3
return %2 : $Array<T> // id: %3
}
// Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A>
sil public_external Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A> : $@thin <T> (@owned _ContiguousArrayBuffer<T>, @thin _ArrayBuffer<T>.Type) -> @owned _ArrayBuffer<T> {
bb0(%0 : $_ContiguousArrayBuffer<T>, %1 : $@thin _ArrayBuffer<T>.Type):
%2 = enum $Optional<Builtin.NativeObject>, #Optional.None!enumelt // user: %47
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%3 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %5
%4 = metatype $@thick T.Type // user: %5
%5 = apply %3<T>(%4) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %6
%6 = struct_extract %5 : $Bool, #Bool.value // user: %7
cond_br %6, bb1, bb2 // id: %7
bb1: // Preds: bb0
// function_ref Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
%8 = function_ref Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, Bool, Bool, @thick _IndirectArrayBuffer.Type) -> @owned _IndirectArrayBuffer // user: %17
%9 = metatype $@thick _IndirectArrayBuffer.Type // user: %17
%10 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %11
%11 = struct_extract %10 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // user: %16
%12 = integer_literal $Builtin.Int1, -1 // user: %13
%13 = struct $Bool (%12 : $Builtin.Int1) // user: %17
%14 = integer_literal $Builtin.Int1, 0 // user: %15
%15 = struct $Bool (%14 : $Builtin.Int1) // user: %17
retain_value %11 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %16
%17 = apply %8<T>(%0, %13, %15, %9) : $@thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, Bool, Bool, @thick _IndirectArrayBuffer.Type) -> @owned _IndirectArrayBuffer // user: %18
%18 = unchecked_ref_cast %17 : $_IndirectArrayBuffer to $Builtin.NativeObject // user: %19
%19 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %18 : $Builtin.NativeObject // user: %20
br bb5(%19 : $Optional<Builtin.NativeObject>) // id: %20
bb2: // Preds: bb0
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%21 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %30
%22 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %28, %30, %32
%23 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %24
%24 = struct_extract %23 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // users: %26, %35
// function_ref Swift._ContiguousArrayBuffer._storage.getter : Swift.Optional<Swift._ContiguousArrayStorage<A>>
%25 = function_ref Swift._ContiguousArrayBuffer._storage.getter : Swift._ContiguousArrayStorage<A>? : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> @owned Optional<_ContiguousArrayStorage<τ_0_0>> // users: %27, %36
retain_value %24 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %26
%27 = apply %25<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> @owned Optional<_ContiguousArrayStorage<τ_0_0>> // user: %28
store %27 to %22#1 : $*Optional<_ContiguousArrayStorage<T>> // id: %28
%29 = struct $_OptionalNilComparisonType () // user: %30
%30 = apply %21<_ContiguousArrayStorage<T>>(%22#1, %29) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %31
%31 = struct_extract %30 : $Bool, #Bool.value // user: %33
dealloc_stack %22#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %32
cond_br %31, bb3, bb4 // id: %33
bb3: // Preds: bb2
%34 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %37, %40, %45
retain_value %24 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %35
%36 = apply %25<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> @owned Optional<_ContiguousArrayStorage<τ_0_0>> // user: %37
store %36 to %34#1 : $*Optional<_ContiguousArrayStorage<T>> // id: %37
// function_ref Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
%38 = function_ref Swift._getOptionalValue <A>(A?) -> A : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> () // user: %40
%39 = alloc_stack $_ContiguousArrayStorage<T> // users: %40, %41, %44
%40 = apply [transparent] %38<_ContiguousArrayStorage<T>>(%39#1, %34#1) : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> ()
%41 = load %39#1 : $*_ContiguousArrayStorage<T> // user: %42
%42 = unchecked_ref_cast %41 : $_ContiguousArrayStorage<T> to $Builtin.NativeObject // user: %43
%43 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %42 : $Builtin.NativeObject // user: %46
dealloc_stack %39#0 : $*@local_storage _ContiguousArrayStorage<T> // id: %44
dealloc_stack %34#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %45
br bb5(%43 : $Optional<Builtin.NativeObject>) // id: %46
bb4: // Preds: bb2
br bb5(%2 : $Optional<Builtin.NativeObject>) // id: %47
bb5(%48 : $Optional<Builtin.NativeObject>): // Preds: bb1 bb3 bb4
%49 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %50
%50 = struct_extract %49 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // user: %51
release_value %50 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %51
%52 = struct $_ArrayBuffer<T> (%48 : $Optional<Builtin.NativeObject>) // user: %53
return %52 : $_ArrayBuffer<T> // id: %53
}
// Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
sil public_external Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <T> (@thick T.Type) -> Bool {
bb0(%0 : $@thick T.Type):
// function_ref Swift._canBeClass <A>(A.Type) -> Swift.Int8
%1 = function_ref Swift._canBeClass <A>(A.Type) -> Swift.Int8 : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int8 // user: %2
%2 = apply [transparent] %1<T>(%0) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int8 // user: %5
%3 = integer_literal $Builtin.Int8, 0 // user: %6
%4 = builtin_function_ref "cmp_eq_Int8" : $@thin (Builtin.Int8, Builtin.Int8) -> Builtin.Int1 // users: %6, %12
%5 = struct_extract %2 : $Int8, #Int8.value // users: %6, %12
%6 = apply %4(%5, %3) : $@thin (Builtin.Int8, Builtin.Int8) -> Builtin.Int1 // user: %7
cond_br %6, bb1, bb2 // id: %7
bb1: // Preds: bb0
%8 = integer_literal $Builtin.Int1, 0 // user: %9
%9 = struct $Bool (%8 : $Builtin.Int1) // user: %10
br bb3(%9 : $Bool) // id: %10
bb2: // Preds: bb0
%11 = integer_literal $Builtin.Int8, 1 // user: %12
%12 = apply %4(%5, %11) : $@thin (Builtin.Int8, Builtin.Int8) -> Builtin.Int1 // user: %13
cond_br %12, bb4, bb5 // id: %13
bb3(%14 : $Bool): // Preds: bb1 bb4 bb5
return %14 : $Bool // id: %15
bb4: // Preds: bb2
%16 = integer_literal $Builtin.Int1, -1 // user: %17
%17 = struct $Bool (%16 : $Builtin.Int1) // user: %18
br bb3(%17 : $Bool) // id: %18
bb5: // Preds: bb2
// function_ref swift_isClassOrObjCExistential
%19 = function_ref @swift_isClassOrObjCExistential : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %20
%20 = apply %19<T>(%0) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %21
br bb3(%20 : $Bool) // id: %21
}
// Swift._ContiguousArrayBuffer._storage.getter : Swift.Optional<Swift._ContiguousArrayStorage<A>>
sil public_external Swift._ContiguousArrayBuffer._storage.getter : Swift._ContiguousArrayStorage<A>? : $@cc(method) @thin <T> (@owned _ContiguousArrayBuffer<T>) -> @owned Optional<_ContiguousArrayStorage<T>> {
bb0(%0 : $_ContiguousArrayBuffer<T>):
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%1 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %8
%2 = alloc_stack $Optional<HeapBufferStorage<_ArrayBody, T>> // users: %5, %8, %11
%3 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %4
%4 = struct_extract %3 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // user: %5
store %4 to %2#1 : $*Optional<HeapBufferStorage<_ArrayBody, T>> // id: %5
%6 = metatype $@thick Optional<_ContiguousArrayStorage<T>>.Type // user: %8
%7 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %8, %9, %10
%8 = apply [transparent] %1<HeapBufferStorage<_ArrayBody, T>?, _ContiguousArrayStorage<T>?>(%7#1, %2#1, %6) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%9 = load %7#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %12
dealloc_stack %7#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %10
dealloc_stack %2#0 : $*@local_storage Optional<HeapBufferStorage<_ArrayBody, T>> // id: %11
return %9 : $Optional<_ContiguousArrayStorage<T>> // id: %12
}
// Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
sil public_external Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@thin <T> (@owned _ContiguousArrayBuffer<T>, Bool, Bool, @thick _IndirectArrayBuffer.Type) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_ContiguousArrayBuffer<T>, %1 : $Bool, %2 : $Bool, %3 : $@thick _IndirectArrayBuffer.Type):
%4 = alloc_ref $_IndirectArrayBuffer // user: %6
// function_ref Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
%5 = function_ref Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, Bool, Bool, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer // user: %6
%6 = apply %5<T>(%0, %1, %2, %4) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>, Bool, Bool, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer // user: %7
return %6 : $_IndirectArrayBuffer // id: %7
}
// Swift._canBeClass <A>(A.Type) -> Swift.Int8
sil public_external [transparent] Swift._canBeClass <A>(A.Type) -> Swift.Int8 : $@thin <T> (@thick T.Type) -> Int8 {
bb0(%0 : $@thick T.Type):
%1 = metatype $@thick T.Type // user: %3
%2 = builtin_function_ref "canBeClass" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Int8 // user: %3
%3 = apply %2<T>(%1) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Int8 // user: %4
%4 = struct $Int8 (%3 : $Builtin.Int8) // user: %5
return %4 : $Int8 // id: %5
}
// swift_isClassOrObjCExistential
sil @swift_isClassOrObjCExistential : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool
// Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
sil public_external Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@cc(method) @thin <T> (@owned _ContiguousArrayBuffer<T>, Bool, Bool, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_ContiguousArrayBuffer<T>, %1 : $Bool, %2 : $Bool, %3 : $_IndirectArrayBuffer):
%4 = enum $Optional<AnyObject>, #Optional.None!enumelt // users: %6, %25
%5 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // users: %6, %28, %29
store %4 to %5 : $*Optional<AnyObject> // id: %6
%7 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %11, %13, %17, %23, %27
// function_ref Swift._ContiguousArrayBuffer._storage.getter : Swift.Optional<Swift._ContiguousArrayStorage<A>>
%8 = function_ref Swift._ContiguousArrayBuffer._storage.getter : Swift._ContiguousArrayStorage<A>? : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> @owned Optional<_ContiguousArrayStorage<τ_0_0>> // user: %10
retain_value %0 : $_ContiguousArrayBuffer<T> // id: %9
%10 = apply %8<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> @owned Optional<_ContiguousArrayStorage<τ_0_0>> // user: %11
store %10 to %7#1 : $*Optional<_ContiguousArrayStorage<T>> // id: %11
// function_ref Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
%12 = function_ref Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %13
%13 = apply [transparent] %12<_ContiguousArrayStorage<T>>(%7#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %14
cond_br %13, bb1, bb2 // id: %14
bb1: // Preds: bb0
// function_ref Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
%15 = function_ref Swift._getOptionalValue <A>(A?) -> A : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> () // user: %17
%16 = alloc_stack $_ContiguousArrayStorage<T> // users: %17, %18, %21
%17 = apply [transparent] %15<_ContiguousArrayStorage<T>>(%16#1, %7#1) : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> ()
%18 = load %16#1 : $*_ContiguousArrayStorage<T> // user: %19
%19 = init_existential_ref %18 : $_ContiguousArrayStorage<T> : $_ContiguousArrayStorage<T>, $AnyObject // user: %20
%20 = enum $Optional<AnyObject>, #Optional.Some!enumelt.1, %19 : $AnyObject // user: %22
dealloc_stack %16#0 : $*@local_storage _ContiguousArrayStorage<T> // id: %21
br bb3(%20 : $Optional<AnyObject>) // id: %22
bb2: // Preds: bb0
%23 = load %7#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %24
release_value %23 : $Optional<_ContiguousArrayStorage<T>> // id: %24
br bb3(%4 : $Optional<AnyObject>) // id: %25
bb3(%26 : $Optional<AnyObject>): // Preds: bb1 bb2
dealloc_stack %7#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %27
%28 = load %5 : $*Optional<AnyObject> // user: %30
store %26 to %5 : $*Optional<AnyObject> // id: %29
release_value %28 : $Optional<AnyObject> // id: %30
%31 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %32
store %1 to %31 : $*Bool // id: %32
%33 = integer_literal $Builtin.Int1, 0 // user: %34
%34 = struct $Bool (%33 : $Builtin.Int1) // user: %36
%35 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %36
store %34 to %35 : $*Bool // id: %36
%37 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %38
store %2 to %37 : $*Bool // id: %38
release_value %0 : $_ContiguousArrayBuffer<T> // id: %39
return %3 : $_IndirectArrayBuffer // id: %40
}
// Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)(cocoa : Swift._SwiftNSArrayRequiredOverridesType, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
sil public_external Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)(cocoa : Swift._SwiftNSArrayRequiredOverridesType, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@cc(method) @thin (@owned _SwiftNSArrayRequiredOverridesType, Bool, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_SwiftNSArrayRequiredOverridesType, %1 : $Bool, %2 : $_IndirectArrayBuffer):
%3 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // user: %6
%4 = upcast_existential_ref %0 : $_SwiftNSArrayRequiredOverridesType to $AnyObject // user: %5
%5 = enum $Optional<AnyObject>, #Optional.Some!enumelt.1, %4 : $AnyObject // user: %6
store %5 to %3 : $*Optional<AnyObject> // id: %6
%7 = integer_literal $Builtin.Int1, 0 // user: %8
%8 = struct $Bool (%7 : $Builtin.Int1) // user: %10
%9 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %10
store %8 to %9 : $*Bool // id: %10
%11 = integer_literal $Builtin.Int1, -1 // user: %12
%12 = struct $Bool (%11 : $Builtin.Int1) // user: %14
%13 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %14
store %12 to %13 : $*Bool // id: %14
%15 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %16
store %1 to %15 : $*Bool // id: %16
return %2 : $_IndirectArrayBuffer // id: %17
}
// Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(castFrom : Swift._IndirectArrayBuffer, toElementType : A.Type) -> Swift._IndirectArrayBuffer
sil public_external Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(castFrom : Swift._IndirectArrayBuffer, toElementType : A.Type) -> Swift._IndirectArrayBuffer : $@cc(method) @thin <Target> (@owned _IndirectArrayBuffer, @thick Target.Type, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_IndirectArrayBuffer, %1 : $@thick Target.Type, %2 : $_IndirectArrayBuffer):
%3 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // user: %6
%4 = ref_element_addr %0 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // users: %5, %20
%5 = load %4 : $*Optional<AnyObject> // users: %6, %18, %44
store %5 to %3 : $*Optional<AnyObject> // id: %6
%7 = ref_element_addr %0 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // users: %9, %11
%8 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %10
%9 = load %7 : $*Bool // user: %10
store %9 to %8 : $*Bool // id: %10
%11 = struct_element_addr %7 : $*Bool, #Bool.value // user: %12
%12 = load %11 : $*Builtin.Int1 // user: %13
cond_br %12, bb1, bb2 // id: %13
bb1: // Preds: bb0
%14 = integer_literal $Builtin.Int1, 0 // user: %15
%15 = struct $Bool (%14 : $Builtin.Int1) // user: %17
%16 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %17
store %15 to %16 : $*Bool // id: %17
retain_value %5 : $Optional<AnyObject> // id: %18
br bb3 // id: %19
bb2: // Preds: bb0
%20 = load %4 : $*Optional<AnyObject> // users: %21, %38, %45
%21 = enum_is_tag $Builtin.Int1, %20 : $Optional<AnyObject>, #Optional.Some!enumelt.1 // user: %22
cond_br %21, bb4, bb5 // id: %22
bb3: // Preds: bb1 bb11
%23 = ref_element_addr %0 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %24
%24 = struct_element_addr %23 : $*Bool, #Bool.value // user: %25
%25 = load %24 : $*Builtin.Int1 // user: %26
cond_br %25, bb12, bb13 // id: %26
bb4: // Preds: bb2
%27 = integer_literal $Builtin.Int1, -1 // user: %36
%28 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %30, %32
%29 = metatype $@thick Optional<AnyObject>.Type // user: %30
%30 = apply %28<AnyObject?>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %34
%31 = metatype $@thick _ContiguousArrayStorage<AnyObject>.Type // user: %32
%32 = apply %28<_ContiguousArrayStorage<AnyObject>>(%31) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %34
%33 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %34
%34 = apply %33(%30, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %36
%35 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %36
%36 = apply %35(%34, %27) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %37
cond_fail %36 : $Builtin.Int1 // id: %37
%38 = unchecked_ref_bit_cast %20 : $Optional<AnyObject> to $_ContiguousArrayStorage<AnyObject> // user: %39
%39 = enum $Optional<_ContiguousArrayStorage<AnyObject>>, #Optional.Some!enumelt.1, %38 : $_ContiguousArrayStorage<AnyObject> // user: %40
br bb6(%39 : $Optional<_ContiguousArrayStorage<AnyObject>>) // id: %40
bb5: // Preds: bb2
%41 = enum $Optional<_ContiguousArrayStorage<AnyObject>>, #Optional.None!enumelt // user: %42
br bb6(%41 : $Optional<_ContiguousArrayStorage<AnyObject>>) // id: %42
bb6(%43 : $Optional<_ContiguousArrayStorage<AnyObject>>): // Preds: bb4 bb5
retain_value %5 : $Optional<AnyObject> // id: %44
retain_value %20 : $Optional<AnyObject> // id: %45
%46 = integer_literal $Builtin.Int1, 0 // users: %70, %75
%47 = integer_literal $Builtin.Int1, -1 // users: %56, %65, %73
%48 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %50, %52, %63
%49 = metatype $@thick Optional<_ContiguousArrayStorage<AnyObject>>.Type // user: %50
%50 = apply %48<_ContiguousArrayStorage<AnyObject>?>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %54, %64
%51 = metatype $@thick HeapBuffer<_ArrayBody, AnyObject>.Type // user: %52
%52 = apply %48<HeapBuffer<_ArrayBody, AnyObject>>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %54
%53 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %54, %64
%54 = apply %53(%50, %52) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %56
%55 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %56, %65
%56 = apply %55(%54, %47) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %57
cond_fail %56 : $Builtin.Int1 // id: %57
%58 = unchecked_ref_bit_cast %43 : $Optional<_ContiguousArrayStorage<AnyObject>> to $Optional<HeapBufferStorage<_ArrayBody, AnyObject>> // users: %61, %78
%59 = metatype $@thick Target.Type // user: %60
%60 = upcast %59 : $@thick Target.Type to $@thick protocol<>.Type // user: %69
retain_value %58 : $Optional<HeapBufferStorage<_ArrayBody, AnyObject>> // id: %61
%62 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, AnyObject>>.Type // user: %63
%63 = apply %48<HeapBufferStorage<_ArrayBody, AnyObject>?>(%62) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %64
%64 = apply %53(%63, %50) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %65
%65 = apply %55(%64, %47) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %66
cond_fail %65 : $Builtin.Int1 // id: %66
switch_enum %43 : $Optional<_ContiguousArrayStorage<AnyObject>>, case #Optional.Some!enumelt.1: bb7, case #Optional.None!enumelt: bb8 // id: %67
bb7: // Preds: bb6
%68 = unchecked_enum_data %43 : $Optional<_ContiguousArrayStorage<AnyObject>>, #Optional.Some!enumelt.1 // users: %72, %74
checked_cast_br %60 : $@thick protocol<>.Type to $@thick AnyObject.Protocol, bb9, bb10 // id: %69
bb8: // Preds: bb6
br bb11(%46 : $Builtin.Int1) // id: %70
bb9(%71 : $@thick AnyObject.Protocol): // Preds: bb7
strong_release %68 : $_ContiguousArrayStorage<AnyObject> // id: %72
br bb11(%47 : $Builtin.Int1) // id: %73
bb10: // Preds: bb7
strong_release %68 : $_ContiguousArrayStorage<AnyObject> // id: %74
br bb11(%46 : $Builtin.Int1) // id: %75
bb11(%76 : $Builtin.Int1): // Preds: bb8 bb9 bb10
%77 = struct $Bool (%76 : $Builtin.Int1) // user: %80
release_value %58 : $Optional<HeapBufferStorage<_ArrayBody, AnyObject>> // id: %78
%79 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %80
store %77 to %79 : $*Bool // id: %80
br bb3 // id: %81
bb12: // Preds: bb3
%82 = metatype $@thick AnyObject.Protocol // user: %83
checked_cast_br %82 : $@thick AnyObject.Protocol to $@thick Target.Type, bb14, bb15 // id: %83
bb13: // Preds: bb3
%84 = integer_literal $Builtin.Int1, 0 // user: %85
br bb17(%84 : $Builtin.Int1) // id: %85
bb14(%86 : $@thick Target.Type): // Preds: bb12
%87 = integer_literal $Builtin.Int1, -1 // user: %88
br bb16(%87 : $Builtin.Int1) // id: %88
bb15: // Preds: bb12
%89 = integer_literal $Builtin.Int1, 0 // user: %90
br bb16(%89 : $Builtin.Int1) // id: %90
bb16(%91 : $Builtin.Int1): // Preds: bb14 bb15
%92 = integer_literal $Builtin.Int1, -1 // user: %94
%93 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %94
%94 = apply %93(%91, %92) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %95
br bb17(%94 : $Builtin.Int1) // id: %95
bb17(%96 : $Builtin.Int1): // Preds: bb13 bb16
%97 = struct $Bool (%96 : $Builtin.Int1) // user: %99
%98 = ref_element_addr %2 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %99
store %97 to %98 : $*Bool // id: %99
strong_release %0 : $_IndirectArrayBuffer // id: %100
return %2 : $_IndirectArrayBuffer // id: %101
}
// Swift._ContiguousArrayStorage._tryGetVerbatimBridgedUnsafeBuffer <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.UnsafeBufferPointer<Swift.AnyObject>
sil public_external Swift._ContiguousArrayStorage._tryGetVerbatimBridgedUnsafeBuffer <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.UnsafeBufferPointer<Swift.AnyObject> : $@cc(method) @thin <T> (@owned _ContiguousArrayStorage<T>) -> UnsafeBufferPointer<AnyObject> {
bb0(%0 : $_ContiguousArrayStorage<T>):
// function_ref Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
%4 = struct_extract %3 : $Bool, #Bool.value // user: %5
cond_br %4, bb1, bb2 // id: %5
bb1: // Preds: bb0
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift.Optional<Swift._ContiguousArrayStorage<A>>) -> Swift._ContiguousArrayBuffer<A>
%6 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift._ContiguousArrayStorage<A>?) -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %16
%7 = metatype $@thin _ContiguousArrayBuffer<T>.Type // user: %16
%8 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %13, %15, %17
%9 = alloc_stack $_ContiguousArrayStorage<T> // users: %10, %13, %14
store %0 to %9#1 : $*_ContiguousArrayStorage<T> // id: %10
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%11 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %13
strong_retain %0 : $_ContiguousArrayStorage<T> // id: %12
%13 = apply [transparent] %11<_ContiguousArrayStorage<T>>(%8#1, %9#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %9#0 : $*@local_storage _ContiguousArrayStorage<T> // id: %14
%15 = load %8#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %16
%16 = apply %6<T>(%15, %7) : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // users: %20, %24, %27
dealloc_stack %8#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %17
// function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafePointer<A>
%18 = function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafePointer<A> : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %25
%19 = metatype $@thin UnsafePointer<AnyObject>.Type // user: %25
%20 = struct_extract %16 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %21
%21 = struct_extract %20 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // user: %23
// function_ref Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A>
%22 = function_ref Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %24
retain_value %21 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %23
%24 = apply %22<T>(%16) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %25
%25 = apply [transparent] %18<AnyObject, T>(%24, %19) : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // users: %37, %46
// function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int
%26 = function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // user: %27
%27 = apply %26<T>(%16) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // user: %32
%28 = integer_literal $Builtin.Int1, 0 // user: %42
%29 = integer_literal $Builtin.Int1, -1 // user: %35
%30 = integer_literal $Builtin.Word, 0 // user: %33
%31 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %33
%32 = struct_extract %27 : $Int, #Int.value // users: %33, %42
%33 = apply %31(%32, %30) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %35
%34 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %35
%35 = apply %34(%33, %29) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %36
cond_fail %35 : $Builtin.Int1 // id: %36
%37 = struct_extract %25 : $UnsafePointer<AnyObject>, #UnsafePointer.value // user: %44
%38 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %40
%39 = metatype $@thick AnyObject.Protocol // user: %40
%40 = apply %38<AnyObject>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %42
%41 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %42
%42 = apply %41(%32, %40, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%44 = index_raw_pointer %37 : $Builtin.RawPointer, %43 : $Builtin.Word // user: %45
%45 = struct $UnsafePointer<AnyObject> (%44 : $Builtin.RawPointer) // user: %46
%46 = struct $UnsafeBufferPointer<AnyObject> (%25 : $UnsafePointer<AnyObject>, %45 : $UnsafePointer<AnyObject>) // user: %47
br bb3(%46 : $UnsafeBufferPointer<AnyObject>) // id: %47
bb2: // Preds: bb0
%48 = builtin_function_ref "inttoptr_Word" : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %50
%49 = integer_literal $Builtin.Word, 0 // user: %50
%50 = apply %48(%49) : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %51
%51 = struct $UnsafePointer<AnyObject> (%50 : $Builtin.RawPointer) // users: %52, %52
%52 = struct $UnsafeBufferPointer<AnyObject> (%51 : $UnsafePointer<AnyObject>, %51 : $UnsafePointer<AnyObject>) // user: %53
br bb3(%52 : $UnsafeBufferPointer<AnyObject>) // id: %53
bb3(%54 : $UnsafeBufferPointer<AnyObject>): // Preds: bb1 bb2
strong_release %0 : $_ContiguousArrayStorage<T> // id: %55
return %54 : $UnsafeBufferPointer<AnyObject> // id: %56
}
// Swift._ContiguousArrayStorage._getNonVerbatimBridgedCount <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.Int
sil public_external Swift._ContiguousArrayStorage._getNonVerbatimBridgedCount <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.Int : $@cc(method) @thin <T> (@owned _ContiguousArrayStorage<T>) -> Int {
bb0(%0 : $_ContiguousArrayStorage<T>):
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift.Optional<Swift._ContiguousArrayStorage<A>>) -> Swift._ContiguousArrayBuffer<A>
%1 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift._ContiguousArrayStorage<A>?) -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %11
%2 = metatype $@thin _ContiguousArrayBuffer<T>.Type // user: %11
%3 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %8, %10, %15
%4 = alloc_stack $_ContiguousArrayStorage<T> // users: %5, %8, %9
store %0 to %4#1 : $*_ContiguousArrayStorage<T> // id: %5
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%6 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %8
strong_retain %0 : $_ContiguousArrayStorage<T> // id: %7
%8 = apply [transparent] %6<_ContiguousArrayStorage<T>>(%3#1, %4#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %4#0 : $*@local_storage _ContiguousArrayStorage<T> // id: %9
%10 = load %3#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %11
%11 = apply %1<T>(%10, %2) : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %13
// function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int
%12 = function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // user: %13
%13 = apply %12<T>(%11) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // user: %16
strong_release %0 : $_ContiguousArrayStorage<T> // id: %14
dealloc_stack %3#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %15
return %13 : $Int // id: %16
}
// Swift._ContiguousArrayStorage._getNonVerbatimBridgedHeapBuffer <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.HeapBuffer<Swift.Int, Swift.AnyObject>
sil public_external Swift._ContiguousArrayStorage._getNonVerbatimBridgedHeapBuffer <A>(Swift._ContiguousArrayStorage<A>)() -> Swift.HeapBuffer<Swift.Int, Swift.AnyObject> : $@cc(method) @thin <T> (@owned _ContiguousArrayStorage<T>) -> @owned HeapBuffer<Int, AnyObject> {
bb0(%0 : $_ContiguousArrayStorage<T>):
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift.Optional<Swift._ContiguousArrayStorage<A>>) -> Swift._ContiguousArrayBuffer<A>
%1 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift._ContiguousArrayStorage<A>?) -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %11
%2 = metatype $@thin _ContiguousArrayBuffer<T>.Type // user: %11
%3 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %8, %10, %12
%4 = alloc_stack $_ContiguousArrayStorage<T> // users: %5, %8, %9
store %0 to %4#1 : $*_ContiguousArrayStorage<T> // id: %5
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%6 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %8
strong_retain %0 : $_ContiguousArrayStorage<T> // id: %7
%8 = apply [transparent] %6<_ContiguousArrayStorage<T>>(%3#1, %4#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %4#0 : $*@local_storage _ContiguousArrayStorage<T> // id: %9
%10 = load %3#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %11
%11 = apply %1<T>(%10, %2) : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // users: %13, %17, %142
dealloc_stack %3#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %12
%13 = struct_extract %11 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %14
%14 = struct_extract %13 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // users: %16, %130, %141
// function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int
%15 = function_ref Swift._ContiguousArrayBuffer.count.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // user: %17
retain_value %14 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %16
%17 = apply %15<T>(%11) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> Int // users: %66, %117
%18 = metatype $@thick HeapBufferStorage<Int, AnyObject>.Type // users: %19, %93
%19 = upcast %18 : $@thick HeapBufferStorage<Int, AnyObject>.Type to $@thick AnyObject.Type // user: %91
%20 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %22, %45, %92, %93, %103, %105
%21 = metatype $@thick HeapObject.Type // users: %22, %76
%22 = apply %20<HeapObject>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %28
%23 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %25, %51, %76
%24 = metatype $@thick Int.Type // users: %25, %45
%25 = apply %23<Int>(%24) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %28, %37
%26 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %28, %46, %52, %71, %135
%27 = integer_literal $Builtin.Int1, -1 // users: %28, %46, %52, %67, %71, %97, %107, %124
%28 = apply %26(%22, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %29, %30
%29 = tuple_extract %28 : $(Builtin.Word, Builtin.Int1), 0 // user: %35
%30 = tuple_extract %28 : $(Builtin.Word, Builtin.Int1), 1 // user: %31
cond_fail %30 : $Builtin.Int1 // id: %31
%32 = integer_literal $Builtin.Word, 1 // users: %35, %37, %56, %58, %77, %135
%33 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %35, %37, %56, %58, %77
%34 = integer_literal $Builtin.Int1, 0 // users: %35, %37, %56, %58, %77, %113, %118, %135
%35 = apply %33(%29, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %36
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%37 = apply %33(%25, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %38
%38 = tuple_extract %37 : $(Builtin.Word, Builtin.Int1), 0 // users: %39, %42, %81, %83
%39 = struct $Int (%38 : $Builtin.Word) // user: %88
%40 = integer_literal $Builtin.Word, -1 // users: %42, %61
%41 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %42, %61
%42 = apply %41(%38, %40) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %44
%43 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %44, %62
%44 = apply %43(%36, %42) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %46, %113
%45 = apply %20<Int>(%24) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %46
%46 = apply %26(%44, %45, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %47, %48
%47 = tuple_extract %46 : $(Builtin.Word, Builtin.Int1), 0 // user: %52
%48 = tuple_extract %46 : $(Builtin.Word, Builtin.Int1), 1 // user: %49
cond_fail %48 : $Builtin.Int1 // id: %49
%50 = metatype $@thick AnyObject.Protocol // users: %51, %64, %92
%51 = apply %23<AnyObject>(%50) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %52, %58
%52 = apply %26(%47, %51, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %53, %54
%53 = tuple_extract %52 : $(Builtin.Word, Builtin.Int1), 0 // user: %56
%54 = tuple_extract %52 : $(Builtin.Word, Builtin.Int1), 1 // user: %55
cond_fail %54 : $Builtin.Int1 // id: %55
%56 = apply %33(%53, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %57
%57 = tuple_extract %56 : $(Builtin.Word, Builtin.Int1), 0 // user: %62
%58 = apply %33(%51, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %59
%59 = tuple_extract %58 : $(Builtin.Word, Builtin.Int1), 0 // users: %60, %61, %83, %85
%60 = struct $Int (%59 : $Builtin.Word) // users: %87, %128
%61 = apply %41(%59, %40) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %62
%62 = apply %43(%57, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %71, %118
%63 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %64, %112
%64 = apply %63<AnyObject>(%50) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %67
%65 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %67, %113, %118
%66 = struct_extract %17 : $Int, #Int.value // users: %67, %123, %126, %148
%67 = apply %65(%66, %64, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %68, %69
%68 = tuple_extract %67 : $(Builtin.Word, Builtin.Int1), 0 // user: %71
%69 = tuple_extract %67 : $(Builtin.Word, Builtin.Int1), 1 // user: %70
cond_fail %69 : $Builtin.Int1 // id: %70
%71 = apply %26(%62, %68, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %72, %73
%72 = tuple_extract %71 : $(Builtin.Word, Builtin.Int1), 0 // user: %75
%73 = tuple_extract %71 : $(Builtin.Word, Builtin.Int1), 1 // user: %74
cond_fail %73 : $Builtin.Int1 // id: %74
%75 = struct $Int (%72 : $Builtin.Word) // user: %91
%76 = apply %23<HeapObject>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %77
%77 = apply %33(%76, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %78
%78 = tuple_extract %77 : $(Builtin.Word, Builtin.Int1), 0 // users: %79, %81, %85
%79 = struct $Int (%78 : $Builtin.Word) // user: %129
%80 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %81, %83, %85
%81 = apply %80(%78, %38) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %82
cond_br %81, bb1, bb2 // id: %82
bb1: // Preds: bb0
%83 = apply %80(%38, %59) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %84
cond_br %83, bb3, bb4 // id: %84
bb2: // Preds: bb0
%85 = apply %80(%78, %59) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %86
cond_br %85, bb6, bb7 // id: %86
bb3: // Preds: bb1
br bb5(%60 : $Int) // id: %87
bb4: // Preds: bb1
br bb5(%39 : $Int) // id: %88
bb5(%89 : $Int): // Preds: bb3 bb4 bb6 bb7
// function_ref swift_bufferAllocate
%90 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %91
%91 = apply %90(%19, %75, %89) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %99
%92 = apply %20<AnyObject>(%50) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %95
%93 = apply %20<HeapBufferStorage<Int, AnyObject>>(%18) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %95
%94 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %95, %106, %126, %148
%95 = apply %94(%92, %93) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
%96 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %97, %107, %124
%97 = apply %96(%95, %27) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = unchecked_ref_bit_cast %91 : $AnyObject to $HeapBufferStorage<Int, AnyObject> // user: %100
%100 = enum $Optional<HeapBufferStorage<Int, AnyObject>>, #Optional.Some!enumelt.1, %99 : $HeapBufferStorage<Int, AnyObject> // users: %101, %109
%101 = struct $HeapBuffer<Int, AnyObject> (%100 : $Optional<HeapBufferStorage<Int, AnyObject>>) // user: %132
%102 = metatype $@thick Optional<HeapBufferStorage<Int, AnyObject>>.Type // user: %103
%103 = apply %20<HeapBufferStorage<Int, AnyObject>?>(%102) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %106
%104 = metatype $@thick Builtin.NativeObject.Type // user: %105
%105 = apply %20<Builtin.NativeObject>(%104) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %106
%106 = apply %94(%103, %105) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %107
%107 = apply %96(%106, %27) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %108
cond_fail %107 : $Builtin.Int1 // id: %108
%109 = unchecked_ref_bit_cast %100 : $Optional<HeapBufferStorage<Int, AnyObject>> to $Builtin.NativeObject // user: %110
%110 = ref_to_raw_pointer %109 : $Builtin.NativeObject to $Builtin.RawPointer // users: %115, %120
%111 = metatype $@thick Int8.Type // user: %112
%112 = apply %63<Int8>(%111) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %113, %118
%113 = apply %65(%44, %112, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %114
%114 = tuple_extract %113 : $(Builtin.Word, Builtin.Int1), 0 // user: %115
%115 = index_raw_pointer %110 : $Builtin.RawPointer, %114 : $Builtin.Word // user: %116
%116 = pointer_to_address %115 : $Builtin.RawPointer to $*Int // user: %117
store %17 to %116 : $*Int // id: %117
%118 = apply %65(%62, %112, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %119
%119 = tuple_extract %118 : $(Builtin.Word, Builtin.Int1), 0 // user: %120
%120 = index_raw_pointer %110 : $Builtin.RawPointer, %119 : $Builtin.Word // user: %144
%121 = integer_literal $Builtin.Word, 0 // users: %123, %126, %133
%122 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %123
%123 = apply %122(%121, %66) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %124
%124 = apply %96(%123, %27) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %125
cond_fail %124 : $Builtin.Int1 // id: %125
%126 = apply %94(%121, %66) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %127
cond_br %126, bb8, bb9 // id: %127
bb6: // Preds: bb2
br bb5(%60 : $Int) // id: %128
bb7: // Preds: bb2
br bb5(%79 : $Int) // id: %129
bb8: // Preds: bb5 bb10
release_value %14 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %130
strong_release %0 : $_ContiguousArrayStorage<T> // id: %131
return %101 : $HeapBuffer<Int, AnyObject> // id: %132
bb9: // Preds: bb5
br bb10(%121 : $Builtin.Word) // id: %133
bb10(%134 : $Builtin.Word): // Preds: bb9 bb10
%135 = apply %26(%134, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %136
%136 = tuple_extract %135 : $(Builtin.Word, Builtin.Int1), 0 // users: %148, %149
%137 = struct $Int (%134 : $Builtin.Word) // user: %142
// function_ref Swift._bridgeToObjectiveCUnconditional <A>(A) -> Swift.AnyObject
%138 = function_ref Swift._bridgeToObjectiveCUnconditional <A>(A) -> Swift.AnyObject : $@thin <τ_0_0> (@in τ_0_0) -> @owned AnyObject // user: %143
%139 = alloc_stack $T // users: %142, %143, %147
// function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A
%140 = function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> () // user: %142
retain_value %14 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %141
%142 = apply %140<T>(%139#1, %137, %11) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> ()
%143 = apply %138<T>(%139#1) : $@thin <τ_0_0> (@in τ_0_0) -> @owned AnyObject // user: %146
%144 = pointer_to_address %120 : $Builtin.RawPointer to $*AnyObject // user: %145
%145 = index_addr %144 : $*AnyObject, %134 : $Builtin.Word // user: %146
store %143 to %145 : $*AnyObject // id: %146
dealloc_stack %139#0 : $*@local_storage T // id: %147
%148 = apply %94(%136, %66) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %149
cond_br %148, bb8, bb10(%136 : $Builtin.Word) // id: %149
}
// Swift._ContiguousArrayStorage.canStoreElementsOfDynamicType <A>(Swift._ContiguousArrayStorage<A>)(protocol<>.Type) -> Swift.Bool
sil public_external Swift._ContiguousArrayStorage.canStoreElementsOfDynamicType <A>(Swift._ContiguousArrayStorage<A>)(protocol<>.Type) -> Swift.Bool : $@cc(method) @thin <T> (@thick protocol<>.Type, @owned _ContiguousArrayStorage<T>) -> Bool {
bb0(%0 : $@thick protocol<>.Type, %1 : $_ContiguousArrayStorage<T>):
checked_cast_br %0 : $@thick protocol<>.Type to $@thick T.Type, bb1, bb2 // id: %2
bb1(%3 : $@thick T.Type): // Preds: bb0
%4 = integer_literal $Builtin.Int1, -1 // user: %5
br bb3(%4 : $Builtin.Int1) // id: %5
bb2: // Preds: bb0
%6 = integer_literal $Builtin.Int1, 0 // user: %7
br bb3(%6 : $Builtin.Int1) // id: %7
bb3(%8 : $Builtin.Int1): // Preds: bb1 bb2
%9 = struct $Bool (%8 : $Builtin.Int1) // user: %11
strong_release %1 : $_ContiguousArrayStorage<T> // id: %10
return %9 : $Bool // id: %11
}
// Swift._ContiguousArrayStorage.staticElementType.getter : protocol<>.Type
sil public_external Swift._ContiguousArrayStorage.staticElementType.getter : protocol<>.Type : $@cc(method) @thin <T> (@owned _ContiguousArrayStorage<T>) -> @thick protocol<>.Type {
bb0(%0 : $_ContiguousArrayStorage<T>):
%1 = metatype $@thick T.Type // user: %2
%2 = upcast %1 : $@thick T.Type to $@thick protocol<>.Type // user: %4
strong_release %0 : $_ContiguousArrayStorage<T> // id: %3
return %2 : $@thick protocol<>.Type // id: %4
}
// Swift._ContiguousArrayStorage.init <A>(Swift._ContiguousArrayStorage<A>.Type)() -> Swift._ContiguousArrayStorage<A>
sil public_external Swift._ContiguousArrayStorage.init <A>(Swift._ContiguousArrayStorage<A>.Type)() -> Swift._ContiguousArrayStorage<A> : $@cc(method) @thin <T> (@owned _ContiguousArrayStorage<T>) -> @owned _ContiguousArrayStorage<T> {
bb0(%0 : $_ContiguousArrayStorage<T>):
return %0 : $_ContiguousArrayStorage<T> // id: %1
}
// Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool
sil public_external Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool : $@thin <T> (@thick T.Type) -> Bool {
bb0(%0 : $@thick T.Type):
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
return %3 : $Bool // id: %4
}
// Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift.Optional<Swift._ContiguousArrayStorage<A>>) -> Swift._ContiguousArrayBuffer<A>
sil public_external Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift._ContiguousArrayStorage<A>?) -> Swift._ContiguousArrayBuffer<A> : $@thin <T> (@owned Optional<_ContiguousArrayStorage<T>>, @thin _ContiguousArrayBuffer<T>.Type) -> @owned _ContiguousArrayBuffer<T> {
bb0(%0 : $Optional<_ContiguousArrayStorage<T>>, %1 : $@thin _ContiguousArrayBuffer<T>.Type):
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%2 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %7
%3 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %4, %7, %10
store %0 to %3#1 : $*Optional<_ContiguousArrayStorage<T>> // id: %4
%5 = metatype $@thick HeapBuffer<_ArrayBody, T>.Type // user: %7
%6 = alloc_stack $HeapBuffer<_ArrayBody, T> // users: %7, %8, %9
%7 = apply [transparent] %2<_ContiguousArrayStorage<T>?, HeapBuffer<_ArrayBody, T>>(%6#1, %3#1, %5) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%8 = load %6#1 : $*HeapBuffer<_ArrayBody, T> // user: %11
dealloc_stack %6#0 : $*@local_storage HeapBuffer<_ArrayBody, T> // id: %9
dealloc_stack %3#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %10
%11 = struct $_ContiguousArrayBuffer<T> (%8 : $HeapBuffer<_ArrayBody, T>) // user: %12
return %11 : $_ContiguousArrayBuffer<T> // id: %12
}
// Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
sil public_external [transparent] Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <T> (@out Optional<T>, @in T) -> () {
bb0(%0 : $*Optional<T>, %1 : $*T):
// function_ref Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
%2 = function_ref Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> () // user: %6
%3 = metatype $@thin Optional<T>.Type // user: %6
%4 = alloc_stack $T // users: %5, %6, %7
copy_addr %1 to [initialization] %4#1 : $*T // id: %5
%6 = apply [transparent] %2<T>(%0, %4#1, %3) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage T // id: %7
destroy_addr %1 : $*T // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafePointer<A>
sil public_external [transparent] Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafePointer<A> : $@thin <T><U> (UnsafeMutablePointer<U>, @thin UnsafePointer<T>.Type) -> UnsafePointer<T> {
bb0(%0 : $UnsafeMutablePointer<U>, %1 : $@thin UnsafePointer<T>.Type):
%2 = struct_extract %0 : $UnsafeMutablePointer<U>, #UnsafeMutablePointer.value // user: %3
%3 = struct $UnsafePointer<T> (%2 : $Builtin.RawPointer) // user: %4
return %3 : $UnsafePointer<T> // id: %4
}
// Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A>
sil public_external Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <T> (@owned _ContiguousArrayBuffer<T>) -> UnsafeMutablePointer<T> {
bb0(%0 : $_ContiguousArrayBuffer<T>):
%1 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // users: %2, %5, %10
%2 = struct_extract %1 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // users: %4, %9, %17
// function_ref Swift.HeapBuffer.hasStorage.getter : Swift.Bool
%3 = function_ref Swift.HeapBuffer.hasStorage.getter : Swift.Bool : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Bool // user: %5
retain_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %4
%5 = apply %3<_ArrayBody, T>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Bool // user: %6
%6 = struct_extract %5 : $Bool, #Bool.value // user: %7
cond_br %6, bb1, bb2 // id: %7
bb1: // Preds: bb0
// function_ref Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B>
%8 = function_ref Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_1> // user: %10
retain_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %9
%10 = apply %8<_ArrayBody, T>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_1> // user: %11
br bb3(%10 : $UnsafeMutablePointer<T>) // id: %11
bb2: // Preds: bb0
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A>
%12 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %14
%13 = metatype $@thin UnsafeMutablePointer<T>.Type // user: %14
%14 = apply [transparent] %12<T>(%13) : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %15
br bb3(%14 : $UnsafeMutablePointer<T>) // id: %15
bb3(%16 : $UnsafeMutablePointer<T>): // Preds: bb1 bb2
release_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %17
return %16 : $UnsafeMutablePointer<T> // id: %18
}
// Swift._ContiguousArrayBuffer.count.getter : Swift.Int
sil public_external Swift._ContiguousArrayBuffer.count.getter : Swift.Int : $@cc(method) @thin <T> (@owned _ContiguousArrayBuffer<T>) -> Int {
bb0(%0 : $_ContiguousArrayBuffer<T>):
%1 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // users: %2, %5, %11
%2 = struct_extract %1 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // users: %4, %10, %20
// function_ref Swift.HeapBuffer.hasStorage.getter : Swift.Bool
%3 = function_ref Swift.HeapBuffer.hasStorage.getter : Swift.Bool : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Bool // user: %5
retain_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %4
%5 = apply %3<_ArrayBody, T>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Bool // user: %6
%6 = struct_extract %5 : $Bool, #Bool.value // user: %7
cond_br %6, bb1, bb2 // id: %7
bb1: // Preds: bb0
// function_ref Swift.HeapBuffer.value.getter : A
%8 = function_ref Swift.HeapBuffer.value.getter : A : $@cc(method) @thin <τ_0_0, τ_0_1> (@out τ_0_0, @owned HeapBuffer<τ_0_0, τ_0_1>) -> () // user: %11
%9 = alloc_stack $_ArrayBody // users: %11, %12, %14
retain_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %10
%11 = apply %8<_ArrayBody, T>(%9#1, %1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@out τ_0_0, @owned HeapBuffer<τ_0_0, τ_0_1>) -> ()
%12 = struct_element_addr %9#1 : $*_ArrayBody, #_ArrayBody.count // user: %13
%13 = load %12 : $*Int // user: %15
dealloc_stack %9#0 : $*@local_storage _ArrayBody // id: %14
br bb3(%13 : $Int) // id: %15
bb2: // Preds: bb0
%16 = integer_literal $Builtin.Word, 0 // user: %17
%17 = struct $Int (%16 : $Builtin.Word) // user: %18
br bb3(%17 : $Int) // id: %18
bb3(%19 : $Int): // Preds: bb1 bb2
release_value %2 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %20
return %19 : $Int // id: %21
}
// swift_bufferAllocate
sil @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject
// Swift._bridgeToObjectiveCUnconditional <A>(A) -> Swift.AnyObject
sil public_external Swift._bridgeToObjectiveCUnconditional <A>(A) -> Swift.AnyObject : $@thin <T> (@in T) -> @owned AnyObject {
bb0(%0 : $*T):
// function_ref Swift._bridgeToObjectiveC <A>(A) -> Swift.Optional<Swift.AnyObject>
%1 = function_ref Swift._bridgeToObjectiveC <A>(A) -> Swift.AnyObject? : $@thin <τ_0_0> (@in τ_0_0) -> @owned Optional<AnyObject> // user: %4
%2 = alloc_stack $T // users: %3, %4, %5
copy_addr %0 to [initialization] %2#1 : $*T // id: %3
%4 = apply %1<T>(%2#1) : $@thin <τ_0_0> (@in τ_0_0) -> @owned Optional<AnyObject> // users: %7, %11, %12
dealloc_stack %2#0 : $*@local_storage T // id: %5
%6 = integer_literal $Builtin.Int1, -1 // users: %9, %15
%7 = enum_is_tag $Builtin.Int1, %4 : $Optional<AnyObject>, #Optional.Some!enumelt.1 // user: %9
%8 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
%9 = apply %8(%7, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %10
cond_fail %9 : $Builtin.Int1 // id: %10
switch_enum %4 : $Optional<AnyObject>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %11
bb1: // Preds: bb0
%12 = unchecked_enum_data %4 : $Optional<AnyObject>, #Optional.Some!enumelt.1 // user: %14
destroy_addr %0 : $*T // id: %13
return %12 : $AnyObject // id: %14
bb2: // Preds: bb0
cond_fail %6 : $Builtin.Int1 // id: %15
unreachable // id: %16
}
// Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A
sil public_external Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, @owned _ContiguousArrayBuffer<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $_ContiguousArrayBuffer<T>):
// function_ref Swift._ContiguousArrayBuffer._unsafeElementStorage.getter : Swift.UnsafeMutablePointer<A>
%3 = function_ref Swift._ContiguousArrayBuffer._unsafeElementStorage.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %5
retain_value %2 : $_ContiguousArrayBuffer<T> // id: %4
%5 = apply %3<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %7
// function_ref Swift.UnsafeMutablePointer.subscript.getter (Swift.Int) -> A
%6 = function_ref Swift.UnsafeMutablePointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeMutablePointer<τ_0_0>) -> () // user: %7
%7 = apply [transparent] %6<T>(%0, %1, %5) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeMutablePointer<τ_0_0>) -> ()
release_value %2 : $_ContiguousArrayBuffer<T> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
sil public_external [transparent] Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <T> (@out Optional<T>, @in T, @thin Optional<T>.Type) -> () {
bb0(%0 : $*Optional<T>, %1 : $*T, %2 : $@thin Optional<T>.Type):
%3 = init_enum_data_addr %0 : $*Optional<T>, #Optional.Some!enumelt.1 // user: %4
copy_addr [take] %1 to [initialization] %3 : $*T // id: %4
inject_enum_addr %0 : $*Optional<T>, #Optional.Some!enumelt.1 // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift.HeapBuffer.hasStorage.getter : Swift.Bool
sil public_external Swift.HeapBuffer.hasStorage.getter : Swift.Bool : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> Bool {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%1 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %6
%2 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %4, %6, %7
%3 = struct_extract %0 : $HeapBuffer<Value, Element>, #HeapBuffer.storage // user: %4
store %3 to %2#1 : $*Optional<HeapBufferStorage<Value, Element>> // id: %4
%5 = struct $_OptionalNilComparisonType () // user: %6
%6 = apply %1<HeapBufferStorage<Value, Element>>(%2#1, %5) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %8
dealloc_stack %2#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %7
return %6 : $Bool // id: %8
}
// Swift.HeapBuffer.value.getter : A
sil public_external Swift.HeapBuffer.value.getter : A : $@cc(method) @thin <Value, Element> (@out Value, @owned HeapBuffer<Value, Element>) -> () {
bb0(%0 : $*Value, %1 : $HeapBuffer<Value, Element>):
// function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A>
%2 = function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %4
retain_value %1 : $HeapBuffer<Value, Element> // id: %3
%4 = apply %2<Value, Element>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %6
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%5 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %6
%6 = apply [transparent] %5<Value>(%0, %4) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
release_value %1 : $HeapBuffer<Value, Element> // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// Swift.HeapBufferStorage.init <A, B>(Swift.HeapBufferStorage<A, B>.Type)() -> Swift.HeapBufferStorage<A, B>
sil public_external Swift.HeapBufferStorage.init <A, B>(Swift.HeapBufferStorage<A, B>.Type)() -> Swift.HeapBufferStorage<A, B> : $@cc(method) @thin <Value, Element> (@owned HeapBufferStorage<Value, Element>) -> @owned HeapBufferStorage<Value, Element> {
bb0(%0 : $HeapBufferStorage<Value, Element>):
return %0 : $HeapBufferStorage<Value, Element> // id: %1
}
// Swift._bridgeToObjectiveC <A>(A) -> Swift.Optional<Swift.AnyObject>
sil public_external Swift._bridgeToObjectiveC <A>(A) -> Swift.AnyObject? : $@thin <T> (@in T) -> @owned Optional<AnyObject> {
bb0(%0 : $*T):
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
%4 = struct_extract %3 : $Bool, #Bool.value // user: %7
%5 = integer_literal $Builtin.Int1, -1 // user: %7
%6 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %7
%7 = apply %6(%4, %5) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %8
cond_br %7, bb1, bb2 // id: %8
bb1: // Preds: bb0
%9 = alloc_stack $AnyObject // users: %14, %15, %18
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%10 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %14
%11 = alloc_stack $T // users: %12, %14, %17
copy_addr %0 to [initialization] %11#1 : $*T // id: %12
%13 = metatype $@thick AnyObject.Protocol // user: %14
%14 = apply [transparent] %10<T, AnyObject>(%9#1, %11#1, %13) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%15 = load %9#1 : $*AnyObject // user: %16
%16 = enum $Optional<AnyObject>, #Optional.Some!enumelt.1, %15 : $AnyObject // user: %19
dealloc_stack %11#0 : $*@local_storage T // id: %17
dealloc_stack %9#0 : $*@local_storage AnyObject // id: %18
br bb3(%16 : $Optional<AnyObject>) // id: %19
bb2: // Preds: bb0
// function_ref swift_bridgeNonVerbatimToObjectiveC
%20 = function_ref @swift_bridgeNonVerbatimToObjectiveC : $@thin <τ_0_0> (@in τ_0_0) -> @owned Optional<AnyObject> // user: %23
%21 = alloc_stack $T // users: %22, %23, %24
copy_addr %0 to [initialization] %21#1 : $*T // id: %22
%23 = apply %20<T>(%21#1) : $@thin <τ_0_0> (@in τ_0_0) -> @owned Optional<AnyObject> // user: %25
dealloc_stack %21#0 : $*@local_storage T // id: %24
br bb3(%23 : $Optional<AnyObject>) // id: %25
bb3(%26 : $Optional<AnyObject>): // Preds: bb1 bb2
destroy_addr %0 : $*T // id: %27
return %26 : $Optional<AnyObject> // id: %28
}
// Swift._ContiguousArrayBuffer._unsafeElementStorage.getter : Swift.UnsafeMutablePointer<A>
sil public_external Swift._ContiguousArrayBuffer._unsafeElementStorage.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <T> (@owned _ContiguousArrayBuffer<T>) -> UnsafeMutablePointer<T> {
bb0(%0 : $_ContiguousArrayBuffer<T>):
%1 = struct_extract %0 : $_ContiguousArrayBuffer<T>, #_ContiguousArrayBuffer._base // user: %3
// function_ref Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B>
%2 = function_ref Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_1> // user: %3
%3 = apply %2<_ArrayBody, T>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_1> // user: %4
return %3 : $UnsafeMutablePointer<T> // id: %4
}
// Swift.UnsafeMutablePointer.subscript.getter (Swift.Int) -> A
sil public_external [transparent] Swift.UnsafeMutablePointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, UnsafeMutablePointer<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $UnsafeMutablePointer<T>):
// function_ref Swift.+ infix <A>(Swift.UnsafeMutablePointer<A>, Swift.Int) -> Swift.UnsafeMutablePointer<A>
%3 = function_ref Swift.+ infix <A>(Swift.UnsafeMutablePointer<A>, Swift.Int) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (UnsafeMutablePointer<τ_0_0>, Int) -> UnsafeMutablePointer<τ_0_0> // user: %4
%4 = apply [transparent] %3<T>(%2, %1) : $@thin <τ_0_0> (UnsafeMutablePointer<τ_0_0>, Int) -> UnsafeMutablePointer<τ_0_0> // user: %6
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%5 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %6
%6 = apply [transparent] %5<T>(%0, %4) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B>
sil public_external Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B> : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> UnsafeMutablePointer<Element> {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A>
%1 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %20
%2 = metatype $@thin UnsafeMutablePointer<Element>.Type // user: %20
// function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%3 = function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %5
%4 = metatype $@thin HeapBuffer<Value, Element>.Type // user: %5
%5 = apply %3<Value, Element>(%4) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %13
// function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8>
%6 = function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %8
retain_value %0 : $HeapBuffer<Value, Element> // id: %7
%8 = apply %6<Value, Element>(%0) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %9
%9 = struct_extract %8 : $UnsafeMutablePointer<Int8>, #UnsafeMutablePointer.value // user: %18
%10 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%11 = metatype $@thick Int8.Type // user: %12
%12 = apply %10<Int8>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = struct_extract %5 : $Int, #Int.value // user: %16
%14 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %16
%15 = integer_literal $Builtin.Int1, 0 // user: %16
%16 = apply %14(%13, %12, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %18
%18 = index_raw_pointer %9 : $Builtin.RawPointer, %17 : $Builtin.Word // user: %19
%19 = struct $UnsafeMutablePointer<Int8> (%18 : $Builtin.RawPointer) // user: %20
%20 = apply [transparent] %1<Element, Int8>(%19, %2) : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
release_value %0 : $HeapBuffer<Value, Element> // id: %21
return %20 : $UnsafeMutablePointer<Element> // id: %22
}
// Swift.+ infix <A>(Swift.UnsafeMutablePointer<A>, Swift.Int) -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.+ infix <A>(Swift.UnsafeMutablePointer<A>, Swift.Int) -> Swift.UnsafeMutablePointer<A> : $@thin <T> (UnsafeMutablePointer<T>, Int) -> UnsafeMutablePointer<T> {
bb0(%0 : $UnsafeMutablePointer<T>, %1 : $Int):
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%2 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %15
%3 = metatype $@thin UnsafeMutablePointer<T>.Type // user: %15
%4 = struct_extract %0 : $UnsafeMutablePointer<T>, #UnsafeMutablePointer.value // user: %14
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%5 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %7
%6 = metatype $@thick T.Type // user: %7
%7 = apply [transparent] %5<T>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %9
%8 = struct_extract %1 : $Int, #Int.value // user: %12
%9 = struct_extract %7 : $Int, #Int.value // user: %12
%10 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %12
%11 = integer_literal $Builtin.Int1, 0 // user: %12
%12 = apply %10(%8, %9, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %13
%13 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 0 // user: %14
%14 = index_raw_pointer %4 : $Builtin.RawPointer, %13 : $Builtin.Word // user: %15
%15 = apply [transparent] %2<T>(%14, %3) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %16
return %15 : $UnsafeMutablePointer<T> // id: %16
}
// Swift.strideof <A>(A.Type) -> Swift.Int
sil public_external [transparent] Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <T> (@thick T.Type) -> Int {
bb0(%0 : $@thick T.Type):
%1 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A> : $@thin <T><U> (UnsafeMutablePointer<U>, @thin UnsafeMutablePointer<T>.Type) -> UnsafeMutablePointer<T> {
bb0(%0 : $UnsafeMutablePointer<U>, %1 : $@thin UnsafeMutablePointer<T>.Type):
%2 = struct_extract %0 : $UnsafeMutablePointer<U>, #UnsafeMutablePointer.value // user: %3
%3 = struct $UnsafeMutablePointer<T> (%2 : $Builtin.RawPointer) // user: %4
return %3 : $UnsafeMutablePointer<T> // id: %4
}
// Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil public_external Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <Value, Element> (@thin HeapBuffer<Value, Element>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<Value, Element>.Type):
// function_ref Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%1 = function_ref Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %2
%2 = apply %1<Value, Element>(%0) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %7
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%3 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %5
%4 = metatype $@thick Value.Type // user: %5
%5 = apply [transparent] %3<Value>(%4) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %8
%6 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %10, %18
%7 = struct_extract %2 : $Int, #Int.value // user: %10
%8 = struct_extract %5 : $Int, #Int.value // user: %10
%9 = integer_literal $Builtin.Int1, -1 // users: %10, %18
%10 = apply %6(%7, %8, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %11, %12
%11 = tuple_extract %10 : $(Builtin.Word, Builtin.Int1), 0 // user: %18
%12 = tuple_extract %10 : $(Builtin.Word, Builtin.Int1), 1 // user: %13
cond_fail %12 : $Builtin.Int1 // id: %13
// function_ref Swift.alignof <A>(A.Type) -> Swift.Int
%14 = function_ref Swift.alignof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %16
%15 = metatype $@thick Element.Type // user: %16
%16 = apply [transparent] %14<Element>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %17
%17 = struct_extract %16 : $Int, #Int.value // users: %18, %27
%18 = apply %6(%11, %17, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %19, %20
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %25
%20 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 1 // user: %21
cond_fail %20 : $Builtin.Int1 // id: %21
%22 = integer_literal $Builtin.Word, 1 // users: %25, %27
%23 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %25, %27
%24 = integer_literal $Builtin.Int1, 0 // users: %25, %27
%25 = apply %23(%19, %22, %24) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %26
%26 = tuple_extract %25 : $(Builtin.Word, Builtin.Int1), 0 // user: %33
%27 = apply %23(%17, %22, %24) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %28
%28 = tuple_extract %27 : $(Builtin.Word, Builtin.Int1), 0 // user: %31
%29 = integer_literal $Builtin.Word, -1 // user: %31
%30 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %31
%31 = apply %30(%28, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %33
%32 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %33
%33 = apply %32(%26, %31) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %34
%34 = struct $Int (%33 : $Builtin.Word) // user: %35
return %34 : $Int // id: %35
}
// Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8>
sil public_external Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8> : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> UnsafeMutablePointer<Int8> {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject
%1 = function_ref Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> @owned Builtin.NativeObject // user: %3
retain_value %0 : $HeapBuffer<Value, Element> // id: %2
%3 = apply %1<Value, Element>(%0) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> @owned Builtin.NativeObject // users: %4, %6
%4 = ref_to_raw_pointer %3 : $Builtin.NativeObject to $Builtin.RawPointer // user: %5
%5 = struct $UnsafeMutablePointer<Int8> (%4 : $Builtin.RawPointer) // user: %8
strong_release %3 : $Builtin.NativeObject // id: %6
release_value %0 : $HeapBuffer<Value, Element> // id: %7
return %5 : $UnsafeMutablePointer<Int8> // id: %8
}
// Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil public_external Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <Value, Element> (@thin HeapBuffer<Value, Element>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<Value, Element>.Type):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
// function_ref Swift.alignof <A>(A.Type) -> Swift.Int
%4 = function_ref Swift.alignof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %6
%5 = metatype $@thick Value.Type // user: %6
%6 = apply [transparent] %4<Value>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %8
%7 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %10
%8 = struct_extract %6 : $Int, #Int.value // users: %10, %19
%9 = integer_literal $Builtin.Int1, -1 // user: %10
%10 = apply %7(%3, %8, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %11, %12
%11 = tuple_extract %10 : $(Builtin.Word, Builtin.Int1), 0 // user: %17
%12 = tuple_extract %10 : $(Builtin.Word, Builtin.Int1), 1 // user: %13
cond_fail %12 : $Builtin.Int1 // id: %13
%14 = integer_literal $Builtin.Word, 1 // users: %17, %19
%15 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %17, %19
%16 = integer_literal $Builtin.Int1, 0 // users: %17, %19
%17 = apply %15(%11, %14, %16) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %18
%18 = tuple_extract %17 : $(Builtin.Word, Builtin.Int1), 0 // user: %25
%19 = apply %15(%8, %14, %16) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %20
%20 = tuple_extract %19 : $(Builtin.Word, Builtin.Int1), 0 // user: %23
%21 = integer_literal $Builtin.Word, -1 // user: %23
%22 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %23
%23 = apply %22(%20, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %25
%24 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %25
%25 = apply %24(%18, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%26 = struct $Int (%25 : $Builtin.Word) // user: %27
return %26 : $Int // id: %27
}
// Swift.alignof <A>(A.Type) -> Swift.Int
sil public_external [transparent] Swift.alignof <A>(A.Type) -> Swift.Int : $@thin <T> (@thick T.Type) -> Int {
bb0(%0 : $@thick T.Type):
%1 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject
sil public_external Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> @owned Builtin.NativeObject {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%1 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %7
%2 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %4, %7, %10
%3 = struct_extract %0 : $HeapBuffer<Value, Element>, #HeapBuffer.storage // user: %4
store %3 to %2#1 : $*Optional<HeapBufferStorage<Value, Element>> // id: %4
%5 = metatype $@thick Builtin.NativeObject.Type // user: %7
%6 = alloc_stack $Builtin.NativeObject // users: %7, %8, %9
%7 = apply [transparent] %1<HeapBufferStorage<Value, Element>?, Builtin.NativeObject>(%6#1, %2#1, %5) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%8 = load %6#1 : $*Builtin.NativeObject // user: %11
dealloc_stack %6#0 : $*@local_storage Builtin.NativeObject // id: %9
dealloc_stack %2#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %10
return %8 : $Builtin.NativeObject // id: %11
}
// swift_bridgeNonVerbatimToObjectiveC
sil @swift_bridgeNonVerbatimToObjectiveC : $@thin <τ_0_0> (@in τ_0_0) -> @owned Optional<AnyObject>
// Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A>
sil public_external Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> UnsafeMutablePointer<Value> {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A>
%1 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %20
%2 = metatype $@thin UnsafeMutablePointer<Value>.Type // user: %20
// function_ref Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%3 = function_ref Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %5
%4 = metatype $@thin HeapBuffer<Value, Element>.Type // user: %5
%5 = apply %3<Value, Element>(%4) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %13
// function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8>
%6 = function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %8
retain_value %0 : $HeapBuffer<Value, Element> // id: %7
%8 = apply %6<Value, Element>(%0) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %9
%9 = struct_extract %8 : $UnsafeMutablePointer<Int8>, #UnsafeMutablePointer.value // user: %18
%10 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%11 = metatype $@thick Int8.Type // user: %12
%12 = apply %10<Int8>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = struct_extract %5 : $Int, #Int.value // user: %16
%14 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %16
%15 = integer_literal $Builtin.Int1, 0 // user: %16
%16 = apply %14(%13, %12, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %18
%18 = index_raw_pointer %9 : $Builtin.RawPointer, %17 : $Builtin.Word // user: %19
%19 = struct $UnsafeMutablePointer<Int8> (%18 : $Builtin.RawPointer) // user: %20
%20 = apply [transparent] %1<Value, Int8>(%19, %2) : $@thin <τ_0_0><τ_1_0> (UnsafeMutablePointer<τ_1_0>, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
release_value %0 : $HeapBuffer<Value, Element> // id: %21
return %20 : $UnsafeMutablePointer<Value> // id: %22
}
// Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A> : $@thin <T> (@thin UnsafeMutablePointer<T>.Type) -> UnsafeMutablePointer<T> {
bb0(%0 : $@thin UnsafeMutablePointer<T>.Type):
// function_ref Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A>
%1 = function_ref Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %3
%2 = metatype $@thin UnsafeMutablePointer<T>.Type // user: %3
%3 = apply [transparent] %1<T>(%2) : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %4
return %3 : $UnsafeMutablePointer<T> // id: %4
}
// Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A> : $@thin <T> (@thin UnsafeMutablePointer<T>.Type) -> UnsafeMutablePointer<T> {
bb0(%0 : $@thin UnsafeMutablePointer<T>.Type):
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A>
%1 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %3
%2 = metatype $@thin UnsafeMutablePointer<T>.Type // user: %3
%3 = apply [transparent] %1<T>(%2) : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %4
return %3 : $UnsafeMutablePointer<T> // id: %4
}
// Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A>
sil public_external [transparent] Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A> : $@thin <T> (@thin UnsafeMutablePointer<T>.Type) -> UnsafeMutablePointer<T> {
bb0(%0 : $@thin UnsafeMutablePointer<T>.Type):
%1 = builtin_function_ref "inttoptr_Word" : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %3
%2 = integer_literal $Builtin.Word, 0 // user: %3
%3 = apply %1(%2) : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %4
%4 = struct $UnsafeMutablePointer<T> (%3 : $Builtin.RawPointer) // user: %5
return %4 : $UnsafeMutablePointer<T> // id: %5
}
// Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A>
sil public_external [transparent] Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A> : $@thin <T> (Builtin.RawPointer, @thin UnsafePointer<T>.Type) -> UnsafePointer<T> {
bb0(%0 : $Builtin.RawPointer, %1 : $@thin UnsafePointer<T>.Type):
%2 = struct $UnsafePointer<T> (%0 : $Builtin.RawPointer) // user: %3
return %2 : $UnsafePointer<T> // id: %3
}
// Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A>
sil public_external Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A> : $@cc(method) @thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<T>, @in Range<T>) -> () {
bb0(%0 : $*RangeGenerator<T>, %1 : $*Range<T>):
// function_ref Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A>
%2 = function_ref Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A> : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<τ_0_0>, @in Range<τ_0_0>, @thin RangeGenerator<τ_0_0>.Type) -> () // user: %6
%3 = metatype $@thin RangeGenerator<T>.Type // user: %6
%4 = alloc_stack $Range<T> // users: %5, %6, %7
copy_addr %1 to [initialization] %4#1 : $*Range<T> // id: %5
%6 = apply [transparent] %2<T, T.Distance, T.Distance.IntegerLiteralType, T._DisabledRangeIndex>(%0, %4#1, %3) : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<τ_0_0>, @in Range<τ_0_0>, @thin RangeGenerator<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage Range<T> // id: %7
destroy_addr %1 : $*Range<T> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index>
sil public_external Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index> : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<C.Index>, @in C) -> () {
bb0(%0 : $*Range<C.Index>, %1 : $*C):
// function_ref Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A>
%2 = function_ref Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A> : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<τ_0_0>, @in τ_0_0, @in τ_0_0, @thin Range<τ_0_0>.Type) -> () // user: %10
%3 = metatype $@thin Range<C.Index>.Type // user: %10
%4 = alloc_stack $C.Index // users: %6, %10, %12
%5 = witness_method $C, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %6
%6 = apply %5<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%4#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%7 = alloc_stack $C.Index // users: %9, %10, %11
%8 = witness_method $C, #_CollectionType.endIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %9
%9 = apply %8<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%7#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%10 = apply [transparent] %2<C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex>(%0, %4#1, %7#1, %3) : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<τ_0_0>, @in τ_0_0, @in τ_0_0, @thin Range<τ_0_0>.Type) -> ()
dealloc_stack %7#0 : $*@local_storage C.Index // id: %11
dealloc_stack %4#0 : $*@local_storage C.Index // id: %12
destroy_addr %1 : $*C // id: %13
%14 = tuple () // user: %15
return %14 : $() // id: %15
}
// Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> Swift.Optional<A>
sil public_external Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> A? : $@cc(method) @thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<T>, @inout RangeGenerator<T>) -> () {
bb0(%0 : $*Optional<T>, %1 : $*RangeGenerator<T>):
%2 = metatype $@thick T.Type // user: %10
%3 = witness_method $T, #Equatable."=="!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %10
%4 = alloc_stack $T // users: %6, %10, %13
%5 = struct_element_addr %1 : $*RangeGenerator<T>, #RangeGenerator.startIndex // users: %6, %21
copy_addr %5 to [initialization] %4#1 : $*T // id: %6
%7 = alloc_stack $T // users: %9, %10, %12
%8 = struct_element_addr %1 : $*RangeGenerator<T>, #RangeGenerator.endIndex // user: %9
copy_addr %8 to [initialization] %7#1 : $*T // id: %9
%10 = apply %3<T>(%4#1, %7#1, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %11
%11 = struct_extract %10 : $Bool, #Bool.value // user: %14
dealloc_stack %7#0 : $*@local_storage T // id: %12
dealloc_stack %4#0 : $*@local_storage T // id: %13
cond_br %11, bb1, bb2 // id: %14
bb1: // Preds: bb0
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%15 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %17
%16 = metatype $@thin Optional<T>.Type // user: %17
%17 = apply [transparent] %15<T>(%0, %16) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
br bb3 // id: %18
bb2: // Preds: bb0
%19 = alloc_stack $T // users: %21, %23, %24
// function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
%20 = function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> () // user: %21
%21 = apply [transparent] %20<T>(%19#1, %5) : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> ()
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%22 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %23
%23 = apply [transparent] %22<T>(%0, %19#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %19#0 : $*@local_storage T // id: %24
br bb3 // id: %25
bb3: // Preds: bb1 bb2
%26 = tuple () // user: %27
return %26 : $() // id: %27
}
// Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A>
sil public_external Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A> : $@thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>, @in S, @thin LazyForwardCollection<S>.Type) -> () {
bb0(%0 : $*LazyForwardCollection<S>, %1 : $*S, %2 : $@thin LazyForwardCollection<S>.Type):
%3 = alloc_stack $LazyForwardCollection<S> // users: %6, %10, %12
%4 = alloc_stack $S // users: %5, %7, %8
copy_addr %1 to [initialization] %4#1 : $*S // id: %5
%6 = struct_element_addr %3#1 : $*LazyForwardCollection<S>, #LazyForwardCollection._base // user: %7
copy_addr [take] %4#1 to [initialization] %6 : $*S // id: %7
dealloc_stack %4#0 : $*@local_storage S // id: %8
destroy_addr %1 : $*S // id: %9
copy_addr [take] %3#1 to [initialization] %0 : $*LazyForwardCollection<S> // id: %10
%11 = tuple () // user: %13
dealloc_stack %3#0 : $*@local_storage LazyForwardCollection<S> // id: %12
return %11 : $() // id: %13
}
// Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B>
sil public_external Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B> : $@thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>, @in Base, @owned @callee_owned (@out T, @in Base.Generator.Element) -> (), @thin MapCollectionView<Base, T>.Type) -> () {
bb0(%0 : $*MapCollectionView<Base, T>, %1 : $*Base, %2 : $@callee_owned (@out T, @in Base.Generator.Element) -> (), %3 : $@thin MapCollectionView<Base, T>.Type):
%4 = struct_element_addr %0 : $*MapCollectionView<Base, T>, #MapCollectionView._base // user: %5
copy_addr [take] %1 to [initialization] %4 : $*Base // id: %5
%6 = struct_element_addr %0 : $*MapCollectionView<Base, T>, #MapCollectionView._transform // user: %7
store %2 to %6 : $*@callee_owned (@out T, @in Base.Generator.Element) -> () // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A>
sil public_external [transparent] Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A> : $@thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out RangeGenerator<T>, @in Range<T>, @thin RangeGenerator<T>.Type) -> () {
bb0(%0 : $*RangeGenerator<T>, %1 : $*Range<T>, %2 : $@thin RangeGenerator<T>.Type):
%3 = alloc_stack $RangeGenerator<T> // users: %9, %18, %23, %25
%4 = alloc_stack $Range<T> // users: %5, %8, %12
copy_addr %1 to [initialization] %4#1 : $*Range<T> // id: %5
// function_ref Swift.Range.startIndex.getter : A
%6 = function_ref Swift.Range.startIndex.getter : A : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> () // user: %8
%7 = alloc_stack $T // users: %8, %10, %11
%8 = apply %6<T, T.Distance, T.Distance.IntegerLiteralType, T._DisabledRangeIndex>(%7#1, %4#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> ()
%9 = struct_element_addr %3#1 : $*RangeGenerator<T>, #RangeGenerator.startIndex // user: %10
copy_addr [take] %7#1 to [initialization] %9 : $*T // id: %10
dealloc_stack %7#0 : $*@local_storage T // id: %11
dealloc_stack %4#0 : $*@local_storage Range<T> // id: %12
%13 = alloc_stack $Range<T> // users: %14, %17, %21
copy_addr %1 to [initialization] %13#1 : $*Range<T> // id: %14
// function_ref Swift.Range.endIndex.getter : A
%15 = function_ref Swift.Range.endIndex.getter : A : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> () // user: %17
%16 = alloc_stack $T // users: %17, %19, %20
%17 = apply %15<T, T.Distance, T.Distance.IntegerLiteralType, T._DisabledRangeIndex>(%16#1, %13#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> ()
%18 = struct_element_addr %3#1 : $*RangeGenerator<T>, #RangeGenerator.endIndex // user: %19
copy_addr [take] %16#1 to [initialization] %18 : $*T // id: %19
dealloc_stack %16#0 : $*@local_storage T // id: %20
dealloc_stack %13#0 : $*@local_storage Range<T> // id: %21
destroy_addr %1 : $*Range<T> // id: %22
copy_addr [take] %3#1 to [initialization] %0 : $*RangeGenerator<T> // id: %23
%24 = tuple () // user: %26
dealloc_stack %3#0 : $*@local_storage RangeGenerator<T> // id: %25
return %24 : $() // id: %26
}
// Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A>
sil public_external [transparent] Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A> : $@thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Range<T>, @in T, @in T, @thin Range<T>.Type) -> () {
bb0(%0 : $*Range<T>, %1 : $*T, %2 : $*T, %3 : $@thin Range<T>.Type):
%4 = alloc_stack $Range<T> // users: %7, %12, %17, %19
%5 = alloc_stack $T // users: %6, %8, %9
copy_addr %1 to [initialization] %5#1 : $*T // id: %6
%7 = struct_element_addr %4#1 : $*Range<T>, #Range._startIndex // user: %8
copy_addr [take] %5#1 to [initialization] %7 : $*T // id: %8
dealloc_stack %5#0 : $*@local_storage T // id: %9
%10 = alloc_stack $T // users: %11, %13, %14
copy_addr %2 to [initialization] %10#1 : $*T // id: %11
%12 = struct_element_addr %4#1 : $*Range<T>, #Range._endIndex // user: %13
copy_addr [take] %10#1 to [initialization] %12 : $*T // id: %13
dealloc_stack %10#0 : $*@local_storage T // id: %14
destroy_addr %2 : $*T // id: %15
destroy_addr %1 : $*T // id: %16
copy_addr [take] %4#1 to [initialization] %0 : $*Range<T> // id: %17
%18 = tuple () // user: %20
dealloc_stack %4#0 : $*@local_storage Range<T> // id: %19
return %18 : $() // id: %20
}
// Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
sil public_external [transparent] Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin <T where T : _Incrementable> (@out T, @inout T) -> () {
bb0(%0 : $*T, %1 : $*T):
%2 = alloc_stack $T // users: %3, %9, %11
copy_addr %1 to [initialization] %2#1 : $*T // id: %3
%4 = witness_method $T, #_Incrementable.successor!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> () // user: %6
%5 = alloc_stack $T // users: %6, %7, %8
%6 = apply %4<T>(%5#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> ()
copy_addr [take] %5#1 to %1 : $*T // id: %7
dealloc_stack %5#0 : $*@local_storage T // id: %8
copy_addr [take] %2#1 to [initialization] %0 : $*T // id: %9
%10 = tuple () // user: %12
dealloc_stack %2#0 : $*@local_storage T // id: %11
return %10 : $() // id: %12
}
// Swift.Range.startIndex.getter : A
sil public_external Swift.Range.startIndex.getter : A : $@cc(method) @thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T, @in Range<T>) -> () {
bb0(%0 : $*T, %1 : $*Range<T>):
%2 = struct_element_addr %1 : $*Range<T>, #Range._startIndex // user: %3
copy_addr %2 to [initialization] %0 : $*T // id: %3
destroy_addr %1 : $*Range<T> // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// Swift.Range.endIndex.getter : A
sil public_external Swift.Range.endIndex.getter : A : $@cc(method) @thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T, @in Range<T>) -> () {
bb0(%0 : $*T, %1 : $*Range<T>):
%2 = struct_element_addr %1 : $*Range<T>, #Range._endIndex // user: %3
copy_addr %2 to [initialization] %0 : $*T // id: %3
destroy_addr %1 : $*Range<T> // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A>
sil public_external Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A> : $@thin <Base where Base : GeneratorType> (@out EnumerateGenerator<Base>, @in Base, @thin EnumerateGenerator<Base>.Type) -> () {
bb0(%0 : $*EnumerateGenerator<Base>, %1 : $*Base, %2 : $@thin EnumerateGenerator<Base>.Type):
%3 = alloc_stack $EnumerateGenerator<Base> // users: %6, %11, %14, %16
%4 = alloc_stack $Base // users: %5, %7, %8
copy_addr %1 to [initialization] %4#1 : $*Base // id: %5
%6 = struct_element_addr %3#1 : $*EnumerateGenerator<Base>, #EnumerateGenerator.base // user: %7
copy_addr [take] %4#1 to [initialization] %6 : $*Base // id: %7
dealloc_stack %4#0 : $*@local_storage Base // id: %8
%9 = integer_literal $Builtin.Word, 0 // user: %10
%10 = struct $Int (%9 : $Builtin.Word) // user: %12
%11 = struct_element_addr %3#1 : $*EnumerateGenerator<Base>, #EnumerateGenerator.count // user: %12
store %10 to %11 : $*Int // id: %12
destroy_addr %1 : $*Base // id: %13
copy_addr [take] %3#1 to [initialization] %0 : $*EnumerateGenerator<Base> // id: %14
%15 = tuple () // user: %17
dealloc_stack %3#0 : $*@local_storage EnumerateGenerator<Base> // id: %16
return %15 : $() // id: %17
}
// Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A>
sil public_external Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A> : $@thin <Base where Base : SequenceType, Base.Generator : GeneratorType> (@out EnumerateSequence<Base>, @in Base, @thin EnumerateSequence<Base>.Type) -> () {
bb0(%0 : $*EnumerateSequence<Base>, %1 : $*Base, %2 : $@thin EnumerateSequence<Base>.Type):
%3 = alloc_stack $EnumerateSequence<Base> // users: %6, %10, %12
%4 = alloc_stack $Base // users: %5, %7, %8
copy_addr %1 to [initialization] %4#1 : $*Base // id: %5
%6 = struct_element_addr %3#1 : $*EnumerateSequence<Base>, #EnumerateSequence.base // user: %7
copy_addr [take] %4#1 to [initialization] %6 : $*Base // id: %7
dealloc_stack %4#0 : $*@local_storage Base // id: %8
destroy_addr %1 : $*Base // id: %9
copy_addr [take] %3#1 to [initialization] %0 : $*EnumerateSequence<Base> // id: %10
%11 = tuple () // user: %13
dealloc_stack %3#0 : $*@local_storage EnumerateSequence<Base> // id: %12
return %11 : $() // id: %13
}
// Swift.== infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
sil public_external Swift.== infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <T> (@in Optional<T>, _OptionalNilComparisonType) -> Bool {
bb0(%0 : $*Optional<T>, %1 : $_OptionalNilComparisonType):
%2 = alloc_stack $Optional<T> // users: %3, %4, %5, %13
copy_addr %0 to [initialization] %2#1 : $*Optional<T> // id: %3
switch_enum_addr %2#1 : $*Optional<T>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %4
bb1: // Preds: bb0
%5 = unchecked_take_enum_data_addr %2#1 : $*Optional<T>, #Optional.Some!enumelt.1 // user: %6
destroy_addr %5 : $*T // id: %6
%7 = integer_literal $Builtin.Int1, 0 // user: %8
br bb3(%7 : $Builtin.Int1) // id: %8
bb2: // Preds: bb0
%9 = integer_literal $Builtin.Int1, -1 // user: %10
br bb3(%9 : $Builtin.Int1) // id: %10
bb3(%11 : $Builtin.Int1): // Preds: bb1 bb2
%12 = struct $Bool (%11 : $Builtin.Int1) // user: %15
dealloc_stack %2#0 : $*@local_storage Optional<T> // id: %13
destroy_addr %0 : $*Optional<T> // id: %14
return %12 : $Bool // id: %15
}
// Swift._preconditionOptionalHasValue <A>(inout Swift.Optional<A>) -> ()
sil public_external [transparent] Swift._preconditionOptionalHasValue <A>(inout A?) -> () : $@thin <T> (@inout Optional<T>) -> () {
bb0(%0 : $*Optional<T>):
%1 = integer_literal $Builtin.Int1, -1 // user: %10
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%2 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %6
%3 = alloc_stack $Optional<T> // users: %4, %6, %7
copy_addr %0 to [initialization] %3#1 : $*Optional<T> // id: %4
%5 = struct $_OptionalNilComparisonType () // user: %6
%6 = apply %2<T>(%3#1, %5) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %9
dealloc_stack %3#0 : $*@local_storage Optional<T> // id: %7
%8 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %10
%9 = struct_extract %6 : $Bool, #Bool.value // user: %10
%10 = apply %8(%9, %1) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %11
cond_fail %10 : $Builtin.Int1 // id: %11
%12 = tuple () // user: %13
return %12 : $() // id: %13
}
// specialization <Swift.Int> of Swift.Array.convertFromHeapArray <A>(Swift.Array<A>.Type)(Builtin.RawPointer, owner : Builtin.NativeObject, count : Builtin.Word) -> Swift.Array<A>
sil shared [readonly] specialization <Swift.Int> of Swift.Array.convertFromHeapArray <A>([A].Type)(Builtin.RawPointer, owner : Builtin.NativeObject, count : Builtin.Word) -> [A] : $@thin (Builtin.RawPointer, @owned Builtin.NativeObject, Builtin.Word, @thin Array<Int>.Type) -> @owned Array<Int> {
bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.NativeObject, %2 : $Builtin.Word, %3 : $@thin Array<Int>.Type):
%4 = integer_literal $Builtin.Int1, -1 // users: %13, %22, %29, %66, %81, %86, %96, %100, %124, %133, %151, %180, %213
%5 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %7, %9, %18, %20, %61, %80, %120, %122, %129, %131, %209, %211
%6 = metatype $@thick Builtin.RawPointer.Type // user: %7
%7 = apply %5<Builtin.RawPointer>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %11
%8 = metatype $@thick UnsafeMutablePointer<Int>.Type // user: %9
%9 = apply %5<UnsafeMutablePointer<Int>>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %11
%10 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %11, %21, %37, %40, %42, %48, %123, %132, %155, %182, %199, %212
%11 = apply %10(%7, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %13
%12 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %13, %22, %29, %124, %133, %180, %213
%13 = apply %12(%11, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %14
cond_fail %13 : $Builtin.Int1 // id: %14
%15 = unchecked_trivial_bit_cast %0 : $Builtin.RawPointer to $UnsafeMutablePointer<Int> // user: %16
%16 = struct_extract %15 : $UnsafeMutablePointer<Int>, #UnsafeMutablePointer.value // user: %194
%17 = metatype $@thick Builtin.Word.Type // user: %18
%18 = apply %5<Builtin.Word>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%19 = metatype $@thick Int.Type // users: %20, %32, %85
%20 = apply %5<Int>(%19) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%21 = apply %10(%18, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%22 = apply %12(%21, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = unchecked_trivial_bit_cast %2 : $Builtin.Word to $Int // user: %27
%25 = integer_literal $Builtin.Word, 0 // users: %28, %37, %48, %56, %57, %143, %144, %171, %179, %182, %185, %185
%26 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %28
%27 = struct_extract %24 : $Int, #Int.value // users: %28, %35
%28 = apply %26(%27, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %29
%29 = apply %12(%28, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %30
cond_fail %29 : $Builtin.Int1 // id: %30
%31 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %32, %138
%32 = apply %31<Int>(%19) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %37, %42, %47, %96, %158, %191
%33 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %35, %96, %139, %175
%34 = integer_literal $Builtin.Int1, 0 // users: %35, %72, %74, %90, %92, %106, %139, %175, %189, %192
%35 = apply %33(%27, %32, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %36
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // users: %40, %47
%37 = apply %10(%32, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = integer_literal $Builtin.Word, -9223372036854775808 // users: %40, %155
%40 = apply %10(%36, %39) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %44
%41 = integer_literal $Builtin.Word, -1 // users: %42, %77, %94
%42 = apply %10(%32, %41) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %44, %156
%43 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %44, %156
%44 = apply %43(%40, %42) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %45
cond_fail %44 : $Builtin.Int1 // id: %45
%46 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %47, %158
%47 = apply %46(%36, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %48, %52, %56, %58, %179, %182, %199
%48 = apply %10(%47, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %49
cond_br %48, bb1, bb2 // id: %49
bb1: // Preds: bb0
%50 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %51
br bb15(%50 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %51
bb2: // Preds: bb0
%52 = struct $Int (%47 : $Builtin.Word) // user: %173
%53 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %54
%54 = upcast %53 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %118
%55 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %56, %111, %113, %202
%56 = apply %55(%25, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %57
cond_br %56, bb3, bb4(%25 : $Builtin.Word) // id: %57
bb3: // Preds: bb2
br bb4(%47 : $Builtin.Word) // id: %58
bb4(%59 : $Builtin.Word): // Preds: bb2 bb3
%60 = metatype $@thick HeapObject.Type // users: %61, %105
%61 = apply %5<HeapObject>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %66
%62 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %64, %85, %105
%63 = metatype $@thick _ArrayBody.Type // users: %64, %80
%64 = apply %62<_ArrayBody>(%63) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %66, %74
%65 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %66, %81, %86, %100, %189, %192
%66 = apply %65(%61, %64, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %67, %68
%67 = tuple_extract %66 : $(Builtin.Word, Builtin.Int1), 0 // user: %72
%68 = tuple_extract %66 : $(Builtin.Word, Builtin.Int1), 1 // user: %69
cond_fail %68 : $Builtin.Int1 // id: %69
%70 = integer_literal $Builtin.Word, 1 // users: %72, %74, %90, %92, %106, %169, %189, %192
%71 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %72, %74, %90, %92, %106, %151
%72 = apply %71(%67, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %73
%73 = tuple_extract %72 : $(Builtin.Word, Builtin.Int1), 0 // user: %79
%74 = apply %71(%64, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %75
%75 = tuple_extract %74 : $(Builtin.Word, Builtin.Int1), 0 // users: %77, %109, %111, %113
%76 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %77, %94
%77 = apply %76(%75, %41) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %79
%78 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %79, %95
%79 = apply %78(%73, %77) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %81, %139
%80 = apply %5<_ArrayBody>(%63) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %81
%81 = apply %65(%79, %80, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %82, %83
%82 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 0 // user: %86
%83 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 1 // user: %84
cond_fail %83 : $Builtin.Int1 // id: %84
%85 = apply %62<Int>(%19) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %86, %92
%86 = apply %65(%82, %85, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %87, %88
%87 = tuple_extract %86 : $(Builtin.Word, Builtin.Int1), 0 // user: %90
%88 = tuple_extract %86 : $(Builtin.Word, Builtin.Int1), 1 // user: %89
cond_fail %88 : $Builtin.Int1 // id: %89
%90 = apply %71(%87, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %91
%91 = tuple_extract %90 : $(Builtin.Word, Builtin.Int1), 0 // user: %95
%92 = apply %71(%85, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %93
%93 = tuple_extract %92 : $(Builtin.Word, Builtin.Int1), 0 // users: %94, %110, %113, %202
%94 = apply %76(%93, %41) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %95
%95 = apply %78(%91, %94) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %100, %151, %175
%96 = apply %33(%59, %32, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %97, %98
%97 = tuple_extract %96 : $(Builtin.Word, Builtin.Int1), 0 // user: %100
%98 = tuple_extract %96 : $(Builtin.Word, Builtin.Int1), 1 // user: %99
cond_fail %98 : $Builtin.Int1 // id: %99
%100 = apply %65(%95, %97, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %101, %102
%101 = tuple_extract %100 : $(Builtin.Word, Builtin.Int1), 0 // user: %104
%102 = tuple_extract %100 : $(Builtin.Word, Builtin.Int1), 1 // user: %103
cond_fail %102 : $Builtin.Int1 // id: %103
%104 = struct $Int (%101 : $Builtin.Word) // user: %118
%105 = apply %62<HeapObject>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %106
%106 = apply %71(%105, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %107
%107 = tuple_extract %106 : $(Builtin.Word, Builtin.Int1), 0 // users: %108, %111, %202
%108 = struct $Int (%107 : $Builtin.Word) // user: %205
%109 = struct $Int (%75 : $Builtin.Word) // user: %201
%110 = struct $Int (%93 : $Builtin.Word) // users: %115, %204
%111 = apply %55(%107, %75) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %112
cond_br %111, bb5, bb12 // id: %112
bb5: // Preds: bb4
%113 = apply %55(%75, %93) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %114
cond_br %113, bb6, bb11 // id: %114
bb6: // Preds: bb5
br bb7(%110 : $Int) // id: %115
bb7(%116 : $Int): // Preds: bb6 bb11 bb13 bb14
// function_ref swift_bufferAllocate
%117 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %118
%118 = apply %117(%54, %104, %116) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %126
%119 = metatype $@thick AnyObject.Protocol // user: %120
%120 = apply %5<AnyObject>(%119) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %123
%121 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %122
%122 = apply %5<HeapBufferStorage<_ArrayBody, Int>>(%121) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %123
%123 = apply %10(%120, %122) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %124
%124 = apply %12(%123, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %125
cond_fail %124 : $Builtin.Int1 // id: %125
%126 = unchecked_ref_bit_cast %118 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %127
%127 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %126 : $HeapBufferStorage<_ArrayBody, Int> // users: %135, %184
%128 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %129
%129 = apply %5<HeapBufferStorage<_ArrayBody, Int>?>(%128) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %132
%130 = metatype $@thick Builtin.NativeObject.Type // user: %131
%131 = apply %5<Builtin.NativeObject>(%130) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %132
%132 = apply %10(%129, %131) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %133
%133 = apply %12(%132, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %134
cond_fail %133 : $Builtin.Int1 // id: %134
%135 = unchecked_ref_bit_cast %127 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %136
%136 = ref_to_raw_pointer %135 : $Builtin.NativeObject to $Builtin.RawPointer // users: %141, %148, %177
%137 = metatype $@thick Int8.Type // user: %138
%138 = apply %31<Int8>(%137) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %139, %175
%139 = apply %33(%79, %138, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %140
%140 = tuple_extract %139 : $(Builtin.Word, Builtin.Int1), 0 // user: %141
%141 = index_raw_pointer %136 : $Builtin.RawPointer, %140 : $Builtin.Word // user: %142
%142 = pointer_to_address %141 : $Builtin.RawPointer to $*_ArrayBody // users: %146, %174
%143 = struct $Int (%25 : $Builtin.Word) // user: %145
%144 = struct $UInt (%25 : $Builtin.Word) // user: %145
%145 = struct $_ArrayBody (%143 : $Int, %144 : $UInt) // user: %146
store %145 to %142 : $*_ArrayBody // id: %146
// function_ref malloc_size
%147 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %149
%148 = struct $UnsafePointer<()> (%136 : $Builtin.RawPointer) // user: %149
%149 = apply %147(%148) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %150
%150 = struct_extract %149 : $UInt, #UInt.value // user: %151
%151 = apply %71(%150, %95, %4) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %152, %153
%152 = tuple_extract %151 : $(Builtin.Word, Builtin.Int1), 0 // users: %155, %158
%153 = tuple_extract %151 : $(Builtin.Word, Builtin.Int1), 1 // user: %154
cond_fail %153 : $Builtin.Int1 // id: %154
%155 = apply %10(%152, %39) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %156
%156 = apply %43(%155, %42) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %157
cond_fail %156 : $Builtin.Int1 // id: %157
%158 = apply %46(%152, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %160
%159 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %160
%160 = apply %159(%158) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %162
%161 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %162
%162 = apply %161(%160) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %163, %164
%163 = tuple_extract %162 : $(Builtin.Int64, Builtin.Int1), 0 // user: %167
%164 = tuple_extract %162 : $(Builtin.Int64, Builtin.Int1), 1 // user: %165
cond_fail %164 : $Builtin.Int1 // id: %165
%166 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %167
%167 = apply %166(%163) : $@thin (Builtin.Int64) -> Builtin.Word // user: %169
%168 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %169
%169 = apply %168(%167, %70) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %171
%170 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %171
%171 = apply %170(%169, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %172
%172 = struct $UInt (%171 : $Builtin.Word) // user: %173
%173 = struct $_ArrayBody (%52 : $Int, %172 : $UInt) // user: %174
store %173 to %142 : $*_ArrayBody // id: %174
%175 = apply %33(%95, %138, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %176
%176 = tuple_extract %175 : $(Builtin.Word, Builtin.Int1), 0 // user: %177
%177 = index_raw_pointer %136 : $Builtin.RawPointer, %176 : $Builtin.Word // user: %185
%178 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %179
%179 = apply %178(%25, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %180
%180 = apply %12(%179, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %181
cond_fail %180 : $Builtin.Int1 // id: %181
%182 = apply %10(%25, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %183
cond_br %182, bb8, bb9 // id: %183
bb8: // Preds: bb7 bb10
br bb15(%127 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %184
bb9: // Preds: bb7
br bb10(%25 : $Builtin.Word, %177 : $Builtin.RawPointer, %25 : $Builtin.Word) // id: %185
bb10(%186 : $Builtin.Word, %187 : $Builtin.RawPointer, %188 : $Builtin.Word): // Preds: bb9 bb10
%189 = apply %65(%186, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %190
%190 = tuple_extract %189 : $(Builtin.Word, Builtin.Int1), 0 // users: %199, %200
%191 = index_raw_pointer %187 : $Builtin.RawPointer, %32 : $Builtin.Word // user: %200
%192 = apply %65(%188, %70, %34) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %193
%193 = tuple_extract %192 : $(Builtin.Word, Builtin.Int1), 0 // user: %200
%194 = pointer_to_address %16 : $Builtin.RawPointer to $*Int // user: %195
%195 = index_addr %194 : $*Int, %188 : $Builtin.Word // user: %196
%196 = load %195 : $*Int // user: %198
%197 = pointer_to_address %187 : $Builtin.RawPointer to $*Int // user: %198
store %196 to %197 : $*Int // id: %198
%199 = apply %10(%190, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %200
cond_br %199, bb8, bb10(%190 : $Builtin.Word, %191 : $Builtin.RawPointer, %193 : $Builtin.Word) // id: %200
bb11: // Preds: bb5
br bb7(%109 : $Int) // id: %201
bb12: // Preds: bb4
%202 = apply %55(%107, %93) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %203
cond_br %202, bb13, bb14 // id: %203
bb13: // Preds: bb12
br bb7(%110 : $Int) // id: %204
bb14: // Preds: bb12
br bb7(%108 : $Int) // id: %205
bb15(%206 : $Optional<HeapBufferStorage<_ArrayBody, Int>>): // Preds: bb1 bb8
%207 = enum $Optional<Builtin.NativeObject>, #Optional.None!enumelt // user: %232
%208 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %209
%209 = apply %5<HeapBufferStorage<_ArrayBody, Int>?>(%208) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %212
%210 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %211
%211 = apply %5<_ContiguousArrayStorage<Int>?>(%210) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %212
%212 = apply %10(%209, %211) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %213
%213 = apply %12(%212, %4) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %214
cond_fail %213 : $Builtin.Int1 // id: %214
%215 = unchecked_ref_bit_cast %206 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %216
%216 = enum_is_tag $Builtin.Int1, %215 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %217
cond_br %216, bb16, bb18 // id: %217
bb16: // Preds: bb15
%218 = unchecked_ref_bit_cast %206 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %219
%219 = unchecked_ref_cast %218 : $_ContiguousArrayStorage<Int> to $Builtin.NativeObject // user: %220
%220 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %219 : $Builtin.NativeObject // user: %221
br bb17(%220 : $Optional<Builtin.NativeObject>) // id: %221
bb17(%222 : $Optional<Builtin.NativeObject>): // Preds: bb16 bb18
%223 = struct $_ArrayBuffer<Int> (%222 : $Optional<Builtin.NativeObject>) // user: %224
%224 = struct $Array<Int> (%223 : $_ArrayBuffer<Int>) // user: %231
%225 = alloc_stack $Builtin.NativeObject // users: %226, %227, %228, %230
store %1 to %225#1 : $*Builtin.NativeObject // id: %226
fix_lifetime %225#1 : $*Builtin.NativeObject // id: %227
%228 = load %225#1 : $*Builtin.NativeObject // user: %229
strong_release %228 : $Builtin.NativeObject // id: %229
dealloc_stack %225#0 : $*@local_storage Builtin.NativeObject // id: %230
return %224 : $Array<Int> // id: %231
bb18: // Preds: bb15
br bb17(%207 : $Optional<Builtin.NativeObject>) // id: %232
}
// specialization <Builtin.RawPointer, Swift.UnsafeMutablePointer<Swift.Int>> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B
sil shared [transparent] specialization <Builtin.RawPointer, Swift.UnsafeMutablePointer<Swift.Int>> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin (@out UnsafeMutablePointer<Int>, @in Builtin.RawPointer, @thick UnsafeMutablePointer<Int>.Type) -> () {
bb0(%0 : $*UnsafeMutablePointer<Int>, %1 : $*Builtin.RawPointer, %2 : $@thick UnsafeMutablePointer<Int>.Type):
%3 = alloc_stack $Builtin.RawPointer // users: %5, %21, %26
%4 = load %1 : $*Builtin.RawPointer // user: %5
store %4 to %3#1 : $*Builtin.RawPointer // id: %5
%6 = integer_literal $Builtin.Int1, -1 // user: %17
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%7 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %9, %11
%8 = metatype $@thick Builtin.RawPointer.Type // user: %9
%9 = apply [transparent] %7<Builtin.RawPointer>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%10 = metatype $@thick UnsafeMutablePointer<Int>.Type // user: %11
%11 = apply [transparent] %7<UnsafeMutablePointer<Int>>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %14
%12 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %15
%13 = struct_extract %9 : $Int, #Int.value // user: %15
%14 = struct_extract %11 : $Int, #Int.value // user: %15
%15 = apply %12(%13, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%19 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
%20 = metatype $@thin UnsafeMutablePointer<UnsafeMutablePointer<Int>>.Type // user: %22
%21 = address_to_pointer %3#1 : $*Builtin.RawPointer to $Builtin.RawPointer // user: %22
%22 = apply [transparent] %19<UnsafeMutablePointer<Int>>(%21, %20) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %24
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%23 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %24
%24 = apply [transparent] %23<UnsafeMutablePointer<Int>>(%0, %22) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
%25 = tuple () // user: %27
dealloc_stack %3#0 : $*@local_storage Builtin.RawPointer // id: %26
return %25 : $() // id: %27
}
// specialization <Swift.UnsafeMutablePointer<Swift.Int> with Swift.UnsafeMutablePointer<Swift.Int> : Swift._PointerType, Swift.UnsafePointer<Swift.Int> with Swift.UnsafePointer<Swift.Int> : Swift._PointerType> of Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B
sil shared [transparent] specialization <Swift.UnsafeMutablePointer<Swift.Int> with Swift.UnsafeMutablePointer<Swift.Int> : Swift._PointerType, Swift.UnsafePointer<Swift.Int> with Swift.UnsafePointer<Swift.Int> : Swift._PointerType> of Swift._convertPointerToPointerArgument <A : Swift._PointerType, B : Swift._PointerType>(A) -> B : $@thin (@out UnsafePointer<Int>, @in UnsafeMutablePointer<Int>) -> () {
bb0(%0 : $*UnsafePointer<Int>, %1 : $*UnsafeMutablePointer<Int>):
%2 = metatype $@thick UnsafePointer<Int>.Type // user: %6
// function_ref protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafeMutablePointer : Swift._PointerType
%3 = function_ref protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafeMutablePointer : Swift._PointerType : $@cc(witness_method) @thin <τ_0_0> (@inout UnsafeMutablePointer<τ_0_0>) -> Builtin.RawPointer // user: %4
%4 = apply %3<Int>(%1) : $@cc(witness_method) @thin <τ_0_0> (@inout UnsafeMutablePointer<τ_0_0>) -> Builtin.RawPointer // user: %6
// function_ref protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafePointer : Swift._PointerType
%5 = function_ref protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafePointer : Swift._PointerType : $@cc(witness_method) @thin <τ_0_0> (@out UnsafePointer<τ_0_0>, Builtin.RawPointer, @thick UnsafePointer<τ_0_0>.Type) -> () // user: %6
%6 = apply %5<Int>(%0, %4, %2) : $@cc(witness_method) @thin <τ_0_0> (@out UnsafePointer<τ_0_0>, Builtin.RawPointer, @thick UnsafePointer<τ_0_0>.Type) -> ()
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// specialization <Swift.Int> of Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A>
sil shared specialization <Swift.Int> of Swift.UnsafeBufferPointer.init <A>(Swift.UnsafeBufferPointer<A>.Type)(start : Swift.UnsafePointer<A>, count : Swift.Int) -> Swift.UnsafeBufferPointer<A> : $@thin (UnsafePointer<Int>, Int, @thin UnsafeBufferPointer<Int>.Type) -> UnsafeBufferPointer<Int> {
bb0(%0 : $UnsafePointer<Int>, %1 : $Int, %2 : $@thin UnsafeBufferPointer<Int>.Type):
%3 = integer_literal $Builtin.Int1, -1 // user: %9
%4 = integer_literal $Builtin.Word, 0 // user: %7
%5 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %7
%6 = struct_extract %1 : $Int, #Int.value // users: %7, %17
%7 = apply %5(%6, %4) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%8 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
%9 = apply %8(%7, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %10
cond_fail %9 : $Builtin.Int1 // id: %10
%11 = struct_extract %0 : $UnsafePointer<Int>, #UnsafePointer.value // user: %19
%12 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %14
%13 = metatype $@thick Int.Type // user: %14
%14 = apply %12<Int>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %17
%15 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%16 = integer_literal $Builtin.Int1, 0 // user: %17
%17 = apply %15(%6, %14, %16) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %18
%18 = tuple_extract %17 : $(Builtin.Word, Builtin.Int1), 0 // user: %19
%19 = index_raw_pointer %11 : $Builtin.RawPointer, %18 : $Builtin.Word // user: %20
%20 = struct $UnsafePointer<Int> (%19 : $Builtin.RawPointer) // user: %21
%21 = struct $UnsafeBufferPointer<Int> (%0 : $UnsafePointer<Int>, %20 : $UnsafePointer<Int>) // user: %22
return %21 : $UnsafeBufferPointer<Int> // id: %22
}
// specialization <Swift.Int> of Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A>
sil shared [transparent] specialization <Swift.Int> of Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A> : $@thin (UnsafePointer<Int>, Int) -> UnsafePointer<Int> {
bb0(%0 : $UnsafePointer<Int>, %1 : $Int):
// function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A>
%2 = function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %15
%3 = metatype $@thin UnsafePointer<Int>.Type // user: %15
%4 = struct_extract %0 : $UnsafePointer<Int>, #UnsafePointer.value // user: %14
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%5 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %7
%6 = metatype $@thick Int.Type // user: %7
%7 = apply [transparent] %5<Int>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %9
%8 = struct_extract %1 : $Int, #Int.value // user: %12
%9 = struct_extract %7 : $Int, #Int.value // user: %12
%10 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %12
%11 = integer_literal $Builtin.Int1, 0 // user: %12
%12 = apply %10(%8, %9, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %13
%13 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 0 // user: %14
%14 = index_raw_pointer %4 : $Builtin.RawPointer, %13 : $Builtin.Word // user: %15
%15 = apply [transparent] %2<Int>(%14, %3) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %16
return %15 : $UnsafePointer<Int> // id: %16
}
// specialization <Swift.Int, Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.SequenceType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType> of Swift.Array.init <A>(Swift.Array<A>.Type)<B : Swift.SequenceType>(B) -> Swift.Array<A>
sil shared specialization <Swift.Int, Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.SequenceType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType> of Swift.Array.init <A>([A].Type)<B : Swift.SequenceType>(B) -> [A] : $@thin (@in UnsafeBufferPointer<Int>, @thin Array<Int>.Type) -> @owned Array<Int> {
bb0(%0 : $*UnsafeBufferPointer<Int>, %1 : $@thin Array<Int>.Type):
%2 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %3
%3 = struct_element_addr %2 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %4
%4 = load %3 : $*Builtin.RawPointer // users: %12, %180
%5 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %6
%6 = struct_element_addr %5 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %7
%7 = load %6 : $*Builtin.RawPointer // user: %11
%8 = integer_literal $Builtin.Word, 0 // users: %18, %30, %38, %39, %129, %130, %157, %165, %168, %171, %171
%9 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %13
%10 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %11, %12
%11 = apply %10(%7) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%12 = apply %10(%4) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%13 = apply %9(%11, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %21, %28
%14 = metatype $@thick Int.Type // users: %16, %69
%15 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %124
%16 = apply %15<Int>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %18, %23, %28, %81, %144, %177
%17 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %18, %21, %23, %30, %108, %118, %141, %168, %185, %200
%18 = apply %17(%16, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = integer_literal $Builtin.Word, -9223372036854775808 // users: %21, %141
%21 = apply %17(%13, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
%22 = integer_literal $Builtin.Word, -1 // users: %23, %61, %78
%23 = apply %17(%16, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %25, %142
%24 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %25, %142
%25 = apply %24(%21, %23) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %26
cond_fail %25 : $Builtin.Int1 // id: %26
%27 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %28, %144
%28 = apply %27(%13, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %30, %34, %38, %40, %165, %168, %185
%29 = integer_literal $Builtin.Int1, 0 // users: %56, %58, %74, %76, %91, %125, %161, %175, %178
%30 = apply %17(%28, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %31
cond_br %30, bb1, bb2 // id: %31
bb1: // Preds: bb0
%32 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %33
br bb15(%32 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %33
bb2: // Preds: bb0
%34 = struct $Int (%28 : $Builtin.Word) // user: %159
%35 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %36
%36 = upcast %35 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %103
%37 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %38, %96, %98, %188
%38 = apply %37(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %39
cond_br %38, bb3, bb4(%8 : $Builtin.Word) // id: %39
bb3: // Preds: bb2
br bb4(%28 : $Builtin.Word) // id: %40
bb4(%41 : $Builtin.Word): // Preds: bb2 bb3
%42 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %44, %64, %105, %107, %115, %117
%43 = metatype $@thick HeapObject.Type // users: %44, %90
%44 = apply %42<HeapObject>(%43) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %50
%45 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %47, %69, %90
%46 = metatype $@thick _ArrayBody.Type // users: %47, %64
%47 = apply %45<_ArrayBody>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %50, %58
%48 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %50, %65, %70, %85, %175, %178
%49 = integer_literal $Builtin.Int1, -1 // users: %50, %65, %70, %81, %85, %110, %119, %137, %166
%50 = apply %48(%44, %47, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %51, %52
%51 = tuple_extract %50 : $(Builtin.Word, Builtin.Int1), 0 // user: %56
%52 = tuple_extract %50 : $(Builtin.Word, Builtin.Int1), 1 // user: %53
cond_fail %52 : $Builtin.Int1 // id: %53
%54 = integer_literal $Builtin.Word, 1 // users: %56, %58, %74, %76, %91, %155, %175, %178
%55 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %56, %58, %74, %76, %91, %137
%56 = apply %55(%51, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %57
%57 = tuple_extract %56 : $(Builtin.Word, Builtin.Int1), 0 // user: %63
%58 = apply %55(%47, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %59
%59 = tuple_extract %58 : $(Builtin.Word, Builtin.Int1), 0 // users: %61, %94, %96, %98
%60 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %61, %78
%61 = apply %60(%59, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %63
%62 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %63, %79
%63 = apply %62(%57, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %65, %125
%64 = apply %42<_ArrayBody>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %65
%65 = apply %48(%63, %64, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %66, %67
%66 = tuple_extract %65 : $(Builtin.Word, Builtin.Int1), 0 // user: %70
%67 = tuple_extract %65 : $(Builtin.Word, Builtin.Int1), 1 // user: %68
cond_fail %67 : $Builtin.Int1 // id: %68
%69 = apply %45<Int>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %70, %76
%70 = apply %48(%66, %69, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %71, %72
%71 = tuple_extract %70 : $(Builtin.Word, Builtin.Int1), 0 // user: %74
%72 = tuple_extract %70 : $(Builtin.Word, Builtin.Int1), 1 // user: %73
cond_fail %72 : $Builtin.Int1 // id: %73
%74 = apply %55(%71, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %75
%75 = tuple_extract %74 : $(Builtin.Word, Builtin.Int1), 0 // user: %79
%76 = apply %55(%69, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %77
%77 = tuple_extract %76 : $(Builtin.Word, Builtin.Int1), 0 // users: %78, %95, %98, %188
%78 = apply %60(%77, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %79
%79 = apply %62(%75, %78) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %85, %137, %161
%80 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %81, %125, %161
%81 = apply %80(%41, %16, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %82, %83
%82 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 0 // user: %85
%83 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 1 // user: %84
cond_fail %83 : $Builtin.Int1 // id: %84
%85 = apply %48(%79, %82, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %86, %87
%86 = tuple_extract %85 : $(Builtin.Word, Builtin.Int1), 0 // user: %89
%87 = tuple_extract %85 : $(Builtin.Word, Builtin.Int1), 1 // user: %88
cond_fail %87 : $Builtin.Int1 // id: %88
%89 = struct $Int (%86 : $Builtin.Word) // user: %103
%90 = apply %45<HeapObject>(%43) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %91
%91 = apply %55(%90, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %92
%92 = tuple_extract %91 : $(Builtin.Word, Builtin.Int1), 0 // users: %93, %96, %188
%93 = struct $Int (%92 : $Builtin.Word) // user: %191
%94 = struct $Int (%59 : $Builtin.Word) // user: %187
%95 = struct $Int (%77 : $Builtin.Word) // users: %100, %190
%96 = apply %37(%92, %59) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
cond_br %96, bb5, bb12 // id: %97
bb5: // Preds: bb4
%98 = apply %37(%59, %77) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %99
cond_br %98, bb6, bb11 // id: %99
bb6: // Preds: bb5
br bb7(%95 : $Int) // id: %100
bb7(%101 : $Int): // Preds: bb6 bb11 bb13 bb14
// function_ref swift_bufferAllocate
%102 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %103
%103 = apply %102(%36, %89, %101) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %112
%104 = metatype $@thick AnyObject.Protocol // user: %105
%105 = apply %42<AnyObject>(%104) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %108
%106 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %107
%107 = apply %42<HeapBufferStorage<_ArrayBody, Int>>(%106) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %108
%108 = apply %17(%105, %107) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %110
%109 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %110, %119, %166
%110 = apply %109(%108, %49) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %111
cond_fail %110 : $Builtin.Int1 // id: %111
%112 = unchecked_ref_bit_cast %103 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %113
%113 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %112 : $HeapBufferStorage<_ArrayBody, Int> // users: %121, %170
%114 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %115
%115 = apply %42<HeapBufferStorage<_ArrayBody, Int>?>(%114) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %118
%116 = metatype $@thick Builtin.NativeObject.Type // user: %117
%117 = apply %42<Builtin.NativeObject>(%116) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %118
%118 = apply %17(%115, %117) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %119
%119 = apply %109(%118, %49) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %120
cond_fail %119 : $Builtin.Int1 // id: %120
%121 = unchecked_ref_bit_cast %113 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %122
%122 = ref_to_raw_pointer %121 : $Builtin.NativeObject to $Builtin.RawPointer // users: %127, %134, %163
%123 = metatype $@thick Int8.Type // user: %124
%124 = apply %15<Int8>(%123) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %125, %161
%125 = apply %80(%63, %124, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %126
%126 = tuple_extract %125 : $(Builtin.Word, Builtin.Int1), 0 // user: %127
%127 = index_raw_pointer %122 : $Builtin.RawPointer, %126 : $Builtin.Word // user: %128
%128 = pointer_to_address %127 : $Builtin.RawPointer to $*_ArrayBody // users: %132, %160
%129 = struct $Int (%8 : $Builtin.Word) // user: %131
%130 = struct $UInt (%8 : $Builtin.Word) // user: %131
%131 = struct $_ArrayBody (%129 : $Int, %130 : $UInt) // user: %132
store %131 to %128 : $*_ArrayBody // id: %132
// function_ref malloc_size
%133 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %135
%134 = struct $UnsafePointer<()> (%122 : $Builtin.RawPointer) // user: %135
%135 = apply %133(%134) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %136
%136 = struct_extract %135 : $UInt, #UInt.value // user: %137
%137 = apply %55(%136, %79, %49) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %138, %139
%138 = tuple_extract %137 : $(Builtin.Word, Builtin.Int1), 0 // users: %141, %144
%139 = tuple_extract %137 : $(Builtin.Word, Builtin.Int1), 1 // user: %140
cond_fail %139 : $Builtin.Int1 // id: %140
%141 = apply %17(%138, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %142
%142 = apply %24(%141, %23) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %143
cond_fail %142 : $Builtin.Int1 // id: %143
%144 = apply %27(%138, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %146
%145 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %146
%146 = apply %145(%144) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %148
%147 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %148
%148 = apply %147(%146) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %149, %150
%149 = tuple_extract %148 : $(Builtin.Int64, Builtin.Int1), 0 // user: %153
%150 = tuple_extract %148 : $(Builtin.Int64, Builtin.Int1), 1 // user: %151
cond_fail %150 : $Builtin.Int1 // id: %151
%152 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %153
%153 = apply %152(%149) : $@thin (Builtin.Int64) -> Builtin.Word // user: %155
%154 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %155
%155 = apply %154(%153, %54) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %157
%156 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %157
%157 = apply %156(%155, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %158
%158 = struct $UInt (%157 : $Builtin.Word) // user: %159
%159 = struct $_ArrayBody (%34 : $Int, %158 : $UInt) // user: %160
store %159 to %128 : $*_ArrayBody // id: %160
%161 = apply %80(%79, %124, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %162
%162 = tuple_extract %161 : $(Builtin.Word, Builtin.Int1), 0 // user: %163
%163 = index_raw_pointer %122 : $Builtin.RawPointer, %162 : $Builtin.Word // user: %171
%164 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %165
%165 = apply %164(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %166
%166 = apply %109(%165, %49) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %167
cond_fail %166 : $Builtin.Int1 // id: %167
%168 = apply %17(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %169
cond_br %168, bb8, bb9 // id: %169
bb8: // Preds: bb7 bb10
br bb15(%113 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // id: %170
bb9: // Preds: bb7
br bb10(%8 : $Builtin.Word, %163 : $Builtin.RawPointer, %8 : $Builtin.Word) // id: %171
bb10(%172 : $Builtin.Word, %173 : $Builtin.RawPointer, %174 : $Builtin.Word): // Preds: bb9 bb10
%175 = apply %48(%172, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %176
%176 = tuple_extract %175 : $(Builtin.Word, Builtin.Int1), 0 // users: %185, %186
%177 = index_raw_pointer %173 : $Builtin.RawPointer, %16 : $Builtin.Word // user: %186
%178 = apply %48(%174, %54, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %179
%179 = tuple_extract %178 : $(Builtin.Word, Builtin.Int1), 0 // user: %186
%180 = pointer_to_address %4 : $Builtin.RawPointer to $*Int // user: %181
%181 = index_addr %180 : $*Int, %174 : $Builtin.Word // user: %182
%182 = load %181 : $*Int // user: %184
%183 = pointer_to_address %173 : $Builtin.RawPointer to $*Int // user: %184
store %182 to %183 : $*Int // id: %184
%185 = apply %17(%176, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %186
cond_br %185, bb8, bb10(%176 : $Builtin.Word, %177 : $Builtin.RawPointer, %179 : $Builtin.Word) // id: %186
bb11: // Preds: bb5
br bb7(%94 : $Int) // id: %187
bb12: // Preds: bb4
%188 = apply %37(%92, %77) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %189
cond_br %188, bb13, bb14 // id: %189
bb13: // Preds: bb12
br bb7(%95 : $Int) // id: %190
bb14: // Preds: bb12
br bb7(%93 : $Int) // id: %191
bb15(%192 : $Optional<HeapBufferStorage<_ArrayBody, Int>>): // Preds: bb1 bb8
%193 = enum $Optional<Builtin.NativeObject>, #Optional.None!enumelt // user: %215
%194 = integer_literal $Builtin.Int1, -1 // user: %202
%195 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %197, %199
%196 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %197
%197 = apply %195<HeapBufferStorage<_ArrayBody, Int>?>(%196) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %200
%198 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %199
%199 = apply %195<_ContiguousArrayStorage<Int>?>(%198) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %200
%200 = apply %17(%197, %199) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %202
%201 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %202
%202 = apply %201(%200, %194) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %203
cond_fail %202 : $Builtin.Int1 // id: %203
%204 = unchecked_ref_bit_cast %192 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %205
%205 = enum_is_tag $Builtin.Int1, %204 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %206
cond_br %205, bb16, bb18 // id: %206
bb16: // Preds: bb15
%207 = unchecked_ref_bit_cast %192 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %208
%208 = unchecked_ref_cast %207 : $_ContiguousArrayStorage<Int> to $Builtin.NativeObject // user: %209
%209 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %208 : $Builtin.NativeObject // user: %210
br bb17(%209 : $Optional<Builtin.NativeObject>) // id: %210
bb17(%211 : $Optional<Builtin.NativeObject>): // Preds: bb16 bb18
%212 = struct $_ArrayBuffer<Int> (%211 : $Optional<Builtin.NativeObject>) // user: %213
%213 = struct $Array<Int> (%212 : $_ArrayBuffer<Int>) // user: %214
return %213 : $Array<Int> // id: %214
bb18: // Preds: bb15
br bb17(%193 : $Optional<Builtin.NativeObject>) // id: %215
}
// specialization <Swift.Int> of Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A>
sil shared specialization <Swift.Int> of Swift._ArrayBuffer.init <A>(Swift._ArrayBuffer<A>.Type)(Swift._ContiguousArrayBuffer<A>) -> Swift._ArrayBuffer<A> : $@thin (@owned _ContiguousArrayBuffer<Int>, @thin _ArrayBuffer<Int>.Type) -> @owned _ArrayBuffer<Int> {
bb0(%0 : $_ContiguousArrayBuffer<Int>, %1 : $@thin _ArrayBuffer<Int>.Type):
%2 = enum $Optional<Builtin.NativeObject>, #Optional.None!enumelt // user: %26
%3 = struct_extract %0 : $_ContiguousArrayBuffer<Int>, #_ContiguousArrayBuffer._base // user: %4
%4 = struct_extract %3 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %16, %22
%5 = integer_literal $Builtin.Int1, -1 // user: %14
%6 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %8, %10
%7 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %8
%8 = apply %6<HeapBufferStorage<_ArrayBody, Int>?>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%9 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %10
%10 = apply %6<_ContiguousArrayStorage<Int>?>(%9) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%11 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %12
%12 = apply %11(%8, %10) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %14
%13 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %14
%14 = apply %13(%12, %5) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %15
cond_fail %14 : $Builtin.Int1 // id: %15
%16 = unchecked_ref_bit_cast %4 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %17
%17 = enum_is_tag $Builtin.Int1, %16 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %18
cond_br %17, bb2, bb3 // id: %18
bb1(%19 : $Optional<Builtin.NativeObject>): // Preds: bb2 bb3
%20 = struct $_ArrayBuffer<Int> (%19 : $Optional<Builtin.NativeObject>) // user: %21
return %20 : $_ArrayBuffer<Int> // id: %21
bb2: // Preds: bb0
%22 = unchecked_ref_bit_cast %4 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %23
%23 = unchecked_ref_cast %22 : $_ContiguousArrayStorage<Int> to $Builtin.NativeObject // user: %24
%24 = enum $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1, %23 : $Builtin.NativeObject // user: %25
br bb1(%24 : $Optional<Builtin.NativeObject>) // id: %25
bb3: // Preds: bb0
br bb1(%2 : $Optional<Builtin.NativeObject>) // id: %26
}
// specialization <Swift.Int> of Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
sil shared specialization <Swift.Int> of Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin (@thick Int.Type) -> Bool {
bb0(%0 : $@thick Int.Type):
%1 = integer_literal $Builtin.Int1, 0 // user: %2
%2 = struct $Bool (%1 : $Builtin.Int1) // user: %3
return %2 : $Bool // id: %3
}
// specialization <Swift.Int> of Swift._canBeClass <A>(A.Type) -> Swift.Int8
sil shared [transparent] specialization <Swift.Int> of Swift._canBeClass <A>(A.Type) -> Swift.Int8 : $@thin (@thick Int.Type) -> Int8 {
bb0(%0 : $@thick Int.Type):
%1 = integer_literal $Builtin.Int8, 0 // user: %2
%2 = struct $Int8 (%1 : $Builtin.Int8) // user: %3
return %2 : $Int8 // id: %3
}
// specialization <Swift.Int> of Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
sil shared specialization <Swift.Int> of Swift._IndirectArrayBuffer.__allocating_init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@thin (@owned _ContiguousArrayBuffer<Int>, Bool, Bool, @thick _IndirectArrayBuffer.Type) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_ContiguousArrayBuffer<Int>, %1 : $Bool, %2 : $Bool, %3 : $@thick _IndirectArrayBuffer.Type):
%4 = alloc_ref $_IndirectArrayBuffer // users: %6, %29, %33, %35, %37
%5 = enum $Optional<AnyObject>, #Optional.None!enumelt // user: %38
%6 = ref_element_addr %4 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // user: %28
%7 = struct_extract %0 : $_ContiguousArrayBuffer<Int>, #_ContiguousArrayBuffer._base // user: %8
%8 = struct_extract %7 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %20, %23
%9 = integer_literal $Builtin.Int1, -1 // user: %18
%10 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %12, %14
%11 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %12
%12 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %14
%14 = apply %10<_ContiguousArrayStorage<Int>?>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%15 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
%16 = apply %15(%12, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
%17 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
%18 = apply %17(%16, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = unchecked_ref_bit_cast %8 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %21
%21 = enum_is_tag $Builtin.Int1, %20 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %22
cond_br %21, bb1, bb3 // id: %22
bb1: // Preds: bb0
%23 = unchecked_ref_bit_cast %8 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %24
%24 = init_existential_ref %23 : $_ContiguousArrayStorage<Int> : $_ContiguousArrayStorage<Int>, $AnyObject // user: %25
%25 = enum $Optional<AnyObject>, #Optional.Some!enumelt.1, %24 : $AnyObject // user: %26
br bb2(%25 : $Optional<AnyObject>) // id: %26
bb2(%27 : $Optional<AnyObject>): // Preds: bb1 bb3
store %27 to %6 : $*Optional<AnyObject> // id: %28
%29 = ref_element_addr %4 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %30
store %1 to %29 : $*Bool // id: %30
%31 = integer_literal $Builtin.Int1, 0 // user: %32
%32 = struct $Bool (%31 : $Builtin.Int1) // user: %34
%33 = ref_element_addr %4 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %34
store %32 to %33 : $*Bool // id: %34
%35 = ref_element_addr %4 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %36
store %2 to %35 : $*Bool // id: %36
return %4 : $_IndirectArrayBuffer // id: %37
bb3: // Preds: bb0
br bb2(%5 : $Optional<AnyObject>) // id: %38
}
// specialization <Swift.Int> of Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer
sil shared specialization <Swift.Int> of Swift._IndirectArrayBuffer.init (Swift._IndirectArrayBuffer.Type)<A>(nativeBuffer : Swift._ContiguousArrayBuffer<A>, isMutable : Swift.Bool, needsElementTypeCheck : Swift.Bool) -> Swift._IndirectArrayBuffer : $@cc(method) @thin (@owned _ContiguousArrayBuffer<Int>, Bool, Bool, @owned _IndirectArrayBuffer) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_ContiguousArrayBuffer<Int>, %1 : $Bool, %2 : $Bool, %3 : $_IndirectArrayBuffer):
%4 = enum $Optional<AnyObject>, #Optional.None!enumelt // user: %37
%5 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.buffer // user: %27
%6 = struct_extract %0 : $_ContiguousArrayBuffer<Int>, #_ContiguousArrayBuffer._base // user: %7
%7 = struct_extract %6 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %19, %22
%8 = integer_literal $Builtin.Int1, -1 // user: %17
%9 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %11, %13
%10 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %11
%11 = apply %9<HeapBufferStorage<_ArrayBody, Int>?>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %15
%12 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %13
%13 = apply %9<_ContiguousArrayStorage<Int>?>(%12) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %15
%14 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %15
%15 = apply %14(%11, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
%19 = unchecked_ref_bit_cast %7 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %20
%20 = enum_is_tag $Builtin.Int1, %19 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %21
cond_br %20, bb1, bb3 // id: %21
bb1: // Preds: bb0
%22 = unchecked_ref_bit_cast %7 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $_ContiguousArrayStorage<Int> // user: %23
%23 = init_existential_ref %22 : $_ContiguousArrayStorage<Int> : $_ContiguousArrayStorage<Int>, $AnyObject // user: %24
%24 = enum $Optional<AnyObject>, #Optional.Some!enumelt.1, %23 : $AnyObject // user: %25
br bb2(%24 : $Optional<AnyObject>) // id: %25
bb2(%26 : $Optional<AnyObject>): // Preds: bb1 bb3
store %26 to %5 : $*Optional<AnyObject> // id: %27
%28 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isMutable // user: %29
store %1 to %28 : $*Bool // id: %29
%30 = integer_literal $Builtin.Int1, 0 // user: %31
%31 = struct $Bool (%30 : $Builtin.Int1) // user: %33
%32 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %33
store %31 to %32 : $*Bool // id: %33
%34 = ref_element_addr %3 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %35
store %2 to %34 : $*Bool // id: %35
return %3 : $_IndirectArrayBuffer // id: %36
bb3: // Preds: bb0
br bb2(%4 : $Optional<AnyObject>) // id: %37
}
// specialization <Swift.Int> of Swift._ContiguousArrayBuffer._storage.getter : Swift.Optional<Swift._ContiguousArrayStorage<A>>
sil shared specialization <Swift.Int> of Swift._ContiguousArrayBuffer._storage.getter : Swift._ContiguousArrayStorage<A>? : $@cc(method) @thin (@owned _ContiguousArrayBuffer<Int>) -> @owned Optional<_ContiguousArrayStorage<Int>> {
bb0(%0 : $_ContiguousArrayBuffer<Int>):
%1 = struct_extract %0 : $_ContiguousArrayBuffer<Int>, #_ContiguousArrayBuffer._base // user: %2
%2 = struct_extract %1 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // user: %14
%3 = integer_literal $Builtin.Int1, -1 // user: %12
%4 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %8
%5 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %6
%6 = apply %4<HeapBufferStorage<_ArrayBody, Int>?>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%7 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %8
%8 = apply %4<_ContiguousArrayStorage<Int>?>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%9 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %10
%10 = apply %9(%6, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %12
%11 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
%12 = apply %11(%10, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %13
cond_fail %12 : $Builtin.Int1 // id: %13
%14 = unchecked_ref_bit_cast %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Optional<_ContiguousArrayStorage<Int>> // user: %15
return %14 : $Optional<_ContiguousArrayStorage<Int>> // id: %15
}
// specialization <Swift.Int> of Swift.Array.init <A>(Swift.Array<A>.Type)(Swift._ArrayBuffer<A>) -> Swift.Array<A>
sil shared specialization <Swift.Int> of Swift.Array.init <A>([A].Type)(Swift._ArrayBuffer<A>) -> [A] : $@thin (@owned _ArrayBuffer<Int>, @thin Array<Int>.Type) -> @owned Array<Int> {
bb0(%0 : $_ArrayBuffer<Int>, %1 : $@thin Array<Int>.Type):
%2 = struct $Array<Int> (%0 : $_ArrayBuffer<Int>) // user: %3
return %2 : $Array<Int> // id: %3
}
// specialization <Swift.Int> of Swift.Array.init <A>(Swift.Array<A>.Type)(arrayLiteral : Swift.Array<A>...) -> Swift.Array<A>
sil shared specialization <Swift.Int> of Swift.Array.init <A>([A].Type)(arrayLiteral : [A]...) -> [A] : $@thin (@owned Array<Int>, @thin Array<Int>.Type) -> @owned Array<Int> {
bb0(%0 : $Array<Int>, %1 : $@thin Array<Int>.Type):
return %0 : $Array<Int> // id: %2
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int with Swift.Int : Swift.Equatable, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of indexof.v1_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> Swift.Optional<A.Index>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int with Swift.Int : Swift.Equatable, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of indexof.v1_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> A.Index? : $@thin (@out Optional<Int>, @in Array<Int>, @owned @callee_owned (@in Int) -> Bool) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*Array<Int>, %2 : $@callee_owned (@in Int) -> Bool):
%3 = alloc_stack $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // users: %11, %17, %94
%4 = load %1 : $*Array<Int> // users: %5, %9
%5 = struct_extract %4 : $Array<Int>, #Array._buffer // user: %6
%6 = struct_extract %5 : $_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %16
// function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool)
%7 = function_ref reabstraction thunk helper <T_0_0 where T_0_0: Swift.CollectionType, T_0_0.Generator: Swift.GeneratorType, T_0_0.Generator.Element: Swift.Equatable, T_0_0.Index: Swift.ForwardIndexType, T_0_0.Index.Distance: Swift._SignedIntegerType, T_0_0.Index.Distance.IntegerLiteralType: Swift._BuiltinIntegerLiteralConvertible> from @callee_owned (@in T_0_0.Generator.Element) -> (@unowned Swift.Bool) to @callee_owned (@in T_0_0.Generator.Element) -> (@out Swift.Bool) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %8
%8 = partial_apply %7<[Int], IndexingGenerator<Array<Int>>, Int, Int, Int, Int, Int, Int>(%2) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Generator.Element : Equatable, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Bool, @in τ_0_0.Generator.Element, @owned @callee_owned (@in τ_0_0.Generator.Element) -> Bool) -> () // user: %9
%9 = struct $MapCollectionView<Array<Int>, Bool> (%4 : $Array<Int>, %8 : $@callee_owned (@out Bool, @in Int) -> ()) // user: %10
%10 = struct $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> (%9 : $MapCollectionView<Array<Int>, Bool>) // user: %11
store %10 to %3#1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %11
%12 = alloc_stack $Bool // users: %15, %93, %204
%13 = integer_literal $Builtin.Int1, -1 // users: %14, %32, %37, %48, %69, %117, %127, %146, %165, %169, %175, %178, %184
%14 = struct $Bool (%13 : $Builtin.Int1) // user: %15
store %14 to %12#1 : $*Bool // id: %15
retain_value %6 : $Optional<Builtin.NativeObject> // id: %16
%17 = struct_element_addr %3#1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %18, %22
%18 = struct_element_addr %17 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %19
%19 = struct_element_addr %18 : $*Array<Int>, #Array._buffer // user: %20
%20 = struct_element_addr %19 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %21, %89, %112
%21 = load %20 : $*Optional<Builtin.NativeObject> // users: %39, %71, %221
%22 = struct_element_addr %17 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // users: %90, %113
%23 = integer_literal $Builtin.Word, 0 // users: %84, %105, %121
%24 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %26, %28, %35, %43, %65, %67, %123, %142, %144, %177
%25 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %26
%26 = apply %24<Builtin.NativeObject?>(%25) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %30
%27 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %28
%28 = apply %24<_ContiguousArrayStorage<Int>?>(%27) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %30, %36
%29 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %30, %36, %68, %84, %145, %214
%30 = apply %29(%26, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %32
%31 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %32, %37, %69, %117, %146, %165, %169, %175
%32 = apply %31(%30, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %33
cond_fail %32 : $Builtin.Int1 // id: %33
%34 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %35
%35 = apply %24<HeapBuffer<_ArrayBody, Int>>(%34) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %36
%36 = apply %29(%28, %35) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %37
%37 = apply %31(%36, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = unchecked_ref_bit_cast %21 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %40
%40 = enum_is_tag $Builtin.Int1, %39 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %41
cond_br %40, bb1, bb9 // id: %41
bb1: // Preds: bb0
%42 = metatype $@thick HeapObject.Type // user: %43
%43 = apply %24<HeapObject>(%42) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %48
%44 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %46
%45 = metatype $@thick _ArrayBody.Type // user: %46
%46 = apply %44<_ArrayBody>(%45) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %48, %57
%47 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %48
%48 = apply %47(%43, %46, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %49, %50
%49 = tuple_extract %48 : $(Builtin.Word, Builtin.Int1), 0 // user: %55
%50 = tuple_extract %48 : $(Builtin.Word, Builtin.Int1), 1 // user: %51
cond_fail %50 : $Builtin.Int1 // id: %51
%52 = integer_literal $Builtin.Word, 1 // users: %55, %57
%53 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %55, %57
%54 = integer_literal $Builtin.Int1, 0 // users: %55, %57, %77
%55 = apply %53(%49, %52, %54) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %56
%56 = tuple_extract %55 : $(Builtin.Word, Builtin.Int1), 0 // user: %63
%57 = apply %53(%46, %52, %54) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %58
%58 = tuple_extract %57 : $(Builtin.Word, Builtin.Int1), 0 // user: %61
%59 = integer_literal $Builtin.Word, -1 // user: %61
%60 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %61
%61 = apply %60(%58, %59) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %63
%62 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %63
%63 = apply %62(%56, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %77
%64 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %65
%65 = apply %24<HeapBufferStorage<_ArrayBody, Int>?>(%64) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %68
%66 = metatype $@thick Builtin.NativeObject.Type // user: %67
%67 = apply %24<Builtin.NativeObject>(%66) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %68
%68 = apply %29(%65, %67) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %69
%69 = apply %31(%68, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %70
cond_fail %69 : $Builtin.Int1 // id: %70
%71 = unchecked_ref_bit_cast %21 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %72
%72 = ref_to_raw_pointer %71 : $Builtin.NativeObject to $Builtin.RawPointer // user: %79
%73 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %75
%74 = metatype $@thick Int8.Type // user: %75
%75 = apply %73<Int8>(%74) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %77
%76 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %77
%77 = apply %76(%63, %75, %54) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %78
%78 = tuple_extract %77 : $(Builtin.Word, Builtin.Int1), 0 // user: %79
%79 = index_raw_pointer %72 : $Builtin.RawPointer, %78 : $Builtin.Word // user: %80
%80 = pointer_to_address %79 : $Builtin.RawPointer to $*_ArrayBody // user: %81
%81 = struct_element_addr %80 : $*_ArrayBody, #_ArrayBody.count // user: %82
%82 = struct_element_addr %81 : $*Int, #Int.value // user: %83
%83 = load %82 : $*Builtin.Word // users: %84, %85
%84 = apply %29(%23, %83) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %85
cond_br %84, bb2, bb4(%83 : $Builtin.Word) // id: %85
bb2: // Preds: bb1 bb7 bb9
%86 = enum $Optional<Int>, #Optional.None!enumelt // user: %87
store %86 to %0 : $*Optional<Int> // id: %87
br bb3 // id: %88
bb3: // Preds: bb2 bb6
%89 = load %20 : $*Optional<Builtin.NativeObject> // user: %91
%90 = load %22 : $*@callee_owned (@out Bool, @in Int) -> () // user: %92
release_value %89 : $Optional<Builtin.NativeObject> // id: %91
strong_release %90 : $@callee_owned (@out Bool, @in Int) -> () // id: %92
dealloc_stack %12#0 : $*@local_storage Bool // id: %93
dealloc_stack %3#0 : $*@local_storage LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %94
%95 = struct_element_addr %1 : $*Array<Int>, #Array._buffer // user: %96
%96 = struct_element_addr %95 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %97
%97 = load %96 : $*Optional<Builtin.NativeObject> // user: %98
release_value %97 : $Optional<Builtin.NativeObject> // id: %98
%99 = tuple () // user: %100
return %99 : $() // id: %100
bb4(%101 : $Builtin.Word): // Preds: bb1
%102 = integer_literal $Builtin.Word, 1 // users: %107, %132, %134, %171, %188, %190, %216
%103 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %127, %171, %178, %184, %216
%104 = integer_literal $Builtin.Int1, 0 // users: %132, %134, %154, %171, %188, %190, %194, %216
%105 = struct $Int (%23 : $Builtin.Word) // user: %106
%106 = enum $Optional<Int>, #Optional.Some!enumelt.1, %105 : $Int // user: %107
br bb5(%102 : $Builtin.Word, %106 : $Optional<Int>) // id: %107
bb5(%108 : $Builtin.Word, %109 : $Optional<Int>): // Preds: bb4 bb8
%110 = unchecked_enum_data %109 : $Optional<Int>, #Optional.Some!enumelt.1 // user: %120
%111 = alloc_stack $Bool // users: %202, %206, %210
%112 = load %20 : $*Optional<Builtin.NativeObject> // users: %115, %148
%113 = load %22 : $*@callee_owned (@out Bool, @in Int) -> () // users: %201, %202
%114 = alloc_stack $Int // users: %200, %202, %203
%115 = unchecked_ref_bit_cast %112 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %116
%116 = enum_is_tag $Builtin.Int1, %115 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %117
%117 = apply %31(%116, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %118
cond_fail %117 : $Builtin.Int1 // id: %118
%119 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %121
%120 = struct_extract %110 : $Int, #Int.value // users: %121, %162, %168, %168, %171, %174, %198
%121 = apply %119(%120, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %164
%122 = metatype $@thick HeapObject.Type // user: %123
%123 = apply %24<HeapObject>(%122) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %127
%124 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %126, %183
%125 = metatype $@thick _ArrayBody.Type // users: %126, %177
%126 = apply %124<_ArrayBody>(%125) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %127, %134
%127 = apply %103(%123, %126, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %128, %129
%128 = tuple_extract %127 : $(Builtin.Word, Builtin.Int1), 0 // user: %132
%129 = tuple_extract %127 : $(Builtin.Word, Builtin.Int1), 1 // user: %130
cond_fail %129 : $Builtin.Int1 // id: %130
%131 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %132, %134, %188, %190
%132 = apply %131(%128, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %133
%133 = tuple_extract %132 : $(Builtin.Word, Builtin.Int1), 0 // user: %140
%134 = apply %131(%126, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %135
%135 = tuple_extract %134 : $(Builtin.Word, Builtin.Int1), 0 // user: %138
%136 = integer_literal $Builtin.Word, -1 // users: %138, %192
%137 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %138, %192
%138 = apply %137(%135, %136) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %140
%139 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %140, %193
%140 = apply %139(%133, %138) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %154, %178
%141 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %142
%142 = apply %24<HeapBufferStorage<_ArrayBody, Int>?>(%141) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %145
%143 = metatype $@thick Builtin.NativeObject.Type // user: %144
%144 = apply %24<Builtin.NativeObject>(%143) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %145
%145 = apply %29(%142, %144) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %146
%146 = apply %31(%145, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %147
cond_fail %146 : $Builtin.Int1 // id: %147
%148 = unchecked_ref_bit_cast %112 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %149
%149 = ref_to_raw_pointer %148 : $Builtin.NativeObject to $Builtin.RawPointer // users: %156, %196
%150 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %152
%151 = metatype $@thick Int8.Type // user: %152
%152 = apply %150<Int8>(%151) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %154, %194
%153 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %154, %194
%154 = apply %153(%140, %152, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %155
%155 = tuple_extract %154 : $(Builtin.Word, Builtin.Int1), 0 // user: %156
%156 = index_raw_pointer %149 : $Builtin.RawPointer, %155 : $Builtin.Word // user: %157
%157 = pointer_to_address %156 : $Builtin.RawPointer to $*_ArrayBody // user: %158
%158 = struct_element_addr %157 : $*_ArrayBody, #_ArrayBody.count // user: %159
%159 = struct_element_addr %158 : $*Int, #Int.value // user: %160
%160 = load %159 : $*Builtin.Word // user: %162
%161 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %162
%162 = apply %161(%120, %160) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %164
%163 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %164
%164 = apply %163(%121, %162) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %165
%165 = apply %31(%164, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %166
cond_fail %165 : $Builtin.Int1 // id: %166
%167 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %168
%168 = apply %167(%120, %120) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %169
%169 = apply %31(%168, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %170
cond_fail %169 : $Builtin.Int1 // id: %170
%171 = apply %103(%120, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %172
%172 = tuple_extract %171 : $(Builtin.Word, Builtin.Int1), 0 // user: %174
%173 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %174
%174 = apply %173(%172, %120) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %175
%175 = apply %31(%174, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %176
cond_fail %175 : $Builtin.Int1 // id: %176
%177 = apply %24<_ArrayBody>(%125) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %178
%178 = apply %103(%140, %177, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %179, %180
%179 = tuple_extract %178 : $(Builtin.Word, Builtin.Int1), 0 // user: %184
%180 = tuple_extract %178 : $(Builtin.Word, Builtin.Int1), 1 // user: %181
cond_fail %180 : $Builtin.Int1 // id: %181
%182 = metatype $@thick Int.Type // user: %183
%183 = apply %124<Int>(%182) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %184, %190
%184 = apply %103(%179, %183, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %185, %186
%185 = tuple_extract %184 : $(Builtin.Word, Builtin.Int1), 0 // user: %188
%186 = tuple_extract %184 : $(Builtin.Word, Builtin.Int1), 1 // user: %187
cond_fail %186 : $Builtin.Int1 // id: %187
%188 = apply %131(%185, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %189
%189 = tuple_extract %188 : $(Builtin.Word, Builtin.Int1), 0 // user: %193
%190 = apply %131(%183, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %191
%191 = tuple_extract %190 : $(Builtin.Word, Builtin.Int1), 0 // user: %192
%192 = apply %137(%191, %136) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %193
%193 = apply %139(%189, %192) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %194
%194 = apply %153(%193, %152, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %195
%195 = tuple_extract %194 : $(Builtin.Word, Builtin.Int1), 0 // user: %196
%196 = index_raw_pointer %149 : $Builtin.RawPointer, %195 : $Builtin.Word // user: %197
%197 = pointer_to_address %196 : $Builtin.RawPointer to $*Int // user: %198
%198 = index_addr %197 : $*Int, %120 : $Builtin.Word // user: %199
%199 = load %198 : $*Int // user: %200
store %199 to %114#1 : $*Int // id: %200
strong_retain %113 : $@callee_owned (@out Bool, @in Int) -> () // id: %201
%202 = apply %113(%111#1, %114#1) : $@callee_owned (@out Bool, @in Int) -> ()
dealloc_stack %114#0 : $*@local_storage Int // id: %203
%204 = struct_element_addr %12#1 : $*Bool, #Bool.value // user: %205
%205 = load %204 : $*Builtin.Int1 // user: %209
%206 = struct_element_addr %111#1 : $*Bool, #Bool.value // user: %207
%207 = load %206 : $*Builtin.Int1 // user: %209
%208 = builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %209
%209 = apply %208(%207, %205) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %211
dealloc_stack %111#0 : $*@local_storage Bool // id: %210
cond_br %209, bb6, bb7 // id: %211
bb6: // Preds: bb5
store %109 to %0 : $*Optional<Int> // id: %212
br bb3 // id: %213
bb7: // Preds: bb5
%214 = apply %29(%108, %101) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %215
cond_br %214, bb2, bb8 // id: %215
bb8: // Preds: bb7
%216 = apply %103(%108, %102, %104) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %217
%217 = tuple_extract %216 : $(Builtin.Word, Builtin.Int1), 0 // user: %220
%218 = struct $Int (%108 : $Builtin.Word) // user: %219
%219 = enum $Optional<Int>, #Optional.Some!enumelt.1, %218 : $Int // user: %220
br bb5(%217 : $Builtin.Word, %219 : $Optional<Int>) // id: %220
bb9: // Preds: bb0
retain_value %21 : $Optional<Builtin.NativeObject> // id: %221
br bb2 // id: %222
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.lazy <A : Swift.CollectionType>(A) -> Swift.LazyForwardCollection<A> : $@thin (@out LazyForwardCollection<Array<Int>>, @in Array<Int>) -> () {
bb0(%0 : $*LazyForwardCollection<Array<Int>>, %1 : $*Array<Int>):
%2 = load %1 : $*Array<Int> // user: %3
%3 = struct $LazyForwardCollection<Array<Int>> (%2 : $Array<Int>) // user: %4
store %3 to %0 : $*LazyForwardCollection<Array<Int>> // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.map <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>)<E>((A.Generator.Element) -> E) -> Swift.LazyForwardCollection<Swift.MapCollectionView<A, E>> : $@cc(method) @thin (@out LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, @owned @callee_owned (@out Bool, @in Int) -> (), @in LazyForwardCollection<Array<Int>>) -> () {
bb0(%0 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, %1 : $@callee_owned (@out Bool, @in Int) -> (), %2 : $*LazyForwardCollection<Array<Int>>):
%3 = struct_element_addr %2 : $*LazyForwardCollection<Array<Int>>, #LazyForwardCollection._base // user: %4
%4 = load %3 : $*Array<Int> // user: %5
%5 = struct $MapCollectionView<Array<Int>, Bool> (%4 : $Array<Int>, %1 : $@callee_owned (@out Bool, @in Int) -> ()) // user: %6
%6 = struct $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> (%5 : $MapCollectionView<Array<Int>, Bool>) // user: %7
store %6 to %0 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.Bool, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.Bool, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.MapCollectionView.init <A : Swift.CollectionType, B>(Swift.MapCollectionView<A, B>.Type)(_base : A, _transform : (A.Generator.Element) -> B) -> Swift.MapCollectionView<A, B> : $@thin (@out MapCollectionView<Array<Int>, Bool>, @in Array<Int>, @owned @callee_owned (@out Bool, @in Int) -> (), @thin MapCollectionView<Array<Int>, Bool>.Type) -> () {
bb0(%0 : $*MapCollectionView<Array<Int>, Bool>, %1 : $*Array<Int>, %2 : $@callee_owned (@out Bool, @in Int) -> (), %3 : $@thin MapCollectionView<Array<Int>, Bool>.Type):
%4 = struct_element_addr %0 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %6
%5 = load %1 : $*Array<Int> // user: %6
store %5 to %4 : $*Array<Int> // id: %6
%7 = struct_element_addr %0 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // user: %8
store %2 to %7 : $*@callee_owned (@out Bool, @in Int) -> () // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A> : $@thin (@out LazyForwardCollection<Array<Int>>, @in Array<Int>, @thin LazyForwardCollection<Array<Int>>.Type) -> () {
bb0(%0 : $*LazyForwardCollection<Array<Int>>, %1 : $*Array<Int>, %2 : $@thin LazyForwardCollection<Array<Int>>.Type):
%3 = load %1 : $*Array<Int> // user: %4
%4 = struct $LazyForwardCollection<Array<Int>> (%3 : $Array<Int>) // user: %5
store %4 to %0 : $*LazyForwardCollection<Array<Int>> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A>
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.init <A : Swift.CollectionType>(Swift.LazyForwardCollection<A>.Type)(A) -> Swift.LazyForwardCollection<A> : $@thin (@out LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, @in MapCollectionView<Array<Int>, Bool>, @thin LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>.Type) -> () {
bb0(%0 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, %1 : $*MapCollectionView<Array<Int>, Bool>, %2 : $@thin LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>.Type):
%3 = load %1 : $*MapCollectionView<Array<Int>, Bool> // user: %4
%4 = struct $LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> (%3 : $MapCollectionView<Array<Int>, Bool>) // user: %5
store %4 to %0 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.LazyForwardCollection<Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool>> with Swift.LazyForwardCollection<Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool>> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool with Swift.Bool : Swift.Equatable, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> Swift.Optional<A.Index>
sil shared specialization <Swift.LazyForwardCollection<Swift.MapCollectionView<[Swift.Int], Swift.Bool>> with Swift.LazyForwardCollection<Swift.MapCollectionView<[Swift.Int], Swift.Bool>> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool with Swift.Bool : Swift.Equatable, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.find <A : Swift.CollectionType>(A, A.Generator.Element) -> A.Index? : $@thin (@out Optional<Int>, @in LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, @in Bool) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, %2 : $*Bool):
%3 = struct_element_addr %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %4, %8
%4 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %5
%5 = struct_element_addr %4 : $*Array<Int>, #Array._buffer // user: %6
%6 = struct_element_addr %5 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %7, %86, %188
%7 = load %6 : $*Optional<Builtin.NativeObject> // users: %26, %58, %73
%8 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // users: %87, %189
%9 = integer_literal $Builtin.Word, 0 // users: %71, %79, %95
%10 = integer_literal $Builtin.Int1, -1 // users: %19, %24, %35, %56, %91, %101, %120, %139, %143, %149, %152, %158
%11 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %13, %15, %22, %30, %52, %54, %97, %116, %118, %151
%12 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %13
%13 = apply %11<Builtin.NativeObject?>(%12) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %17
%14 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %15
%15 = apply %11<_ContiguousArrayStorage<Int>?>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %17, %23
%16 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %17, %23, %55, %71, %119, %194
%17 = apply %16(%13, %15) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
%18 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %19, %24, %56, %91, %120, %139, %143, %149
%19 = apply %18(%17, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %20
cond_fail %19 : $Builtin.Int1 // id: %20
%21 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %22
%22 = apply %11<HeapBuffer<_ArrayBody, Int>>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %23
%23 = apply %16(%15, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
%24 = apply %18(%23, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %25
cond_fail %24 : $Builtin.Int1 // id: %25
%26 = unchecked_ref_bit_cast %7 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %27
%27 = enum_is_tag $Builtin.Int1, %26 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %28
cond_br %27, bb1, bb2 // id: %28
bb1: // Preds: bb0
%29 = metatype $@thick HeapObject.Type // user: %30
%30 = apply %11<HeapObject>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %35
%31 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%32 = metatype $@thick _ArrayBody.Type // user: %33
%33 = apply %31<_ArrayBody>(%32) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %44
%34 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %35
%35 = apply %34(%30, %33, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %36, %37
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %42
%37 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = integer_literal $Builtin.Word, 1 // users: %42, %44
%40 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %44
%41 = integer_literal $Builtin.Int1, 0 // users: %42, %44, %64
%42 = apply %40(%36, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %50
%44 = apply %40(%33, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %45
%45 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%46 = integer_literal $Builtin.Word, -1 // user: %48
%47 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %48
%48 = apply %47(%45, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%49 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%50 = apply %49(%43, %48) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %64
%51 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %52
%52 = apply %11<HeapBufferStorage<_ArrayBody, Int>?>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%53 = metatype $@thick Builtin.NativeObject.Type // user: %54
%54 = apply %11<Builtin.NativeObject>(%53) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%55 = apply %16(%52, %54) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %56
%56 = apply %18(%55, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %57
cond_fail %56 : $Builtin.Int1 // id: %57
%58 = unchecked_ref_bit_cast %7 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %59
%59 = ref_to_raw_pointer %58 : $Builtin.NativeObject to $Builtin.RawPointer // user: %66
%60 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%61 = metatype $@thick Int8.Type // user: %62
%62 = apply %60<Int8>(%61) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %64
%63 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %64
%64 = apply %63(%50, %62, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = tuple_extract %64 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%66 = index_raw_pointer %59 : $Builtin.RawPointer, %65 : $Builtin.Word // user: %67
%67 = pointer_to_address %66 : $Builtin.RawPointer to $*_ArrayBody // user: %68
%68 = struct_element_addr %67 : $*_ArrayBody, #_ArrayBody.count // user: %69
%69 = struct_element_addr %68 : $*Int, #Int.value // user: %70
%70 = load %69 : $*Builtin.Word // users: %71, %72
%71 = apply %16(%9, %70) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
cond_br %71, bb9, bb3(%70 : $Builtin.Word) // id: %72
bb2: // Preds: bb0
retain_value %7 : $Optional<Builtin.NativeObject> // id: %73
br bb9 // id: %74
bb3(%75 : $Builtin.Word): // Preds: bb1
%76 = integer_literal $Builtin.Word, 1 // users: %81, %106, %108, %145, %162, %164, %196
%77 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %101, %145, %152, %158, %196
%78 = integer_literal $Builtin.Int1, 0 // users: %106, %108, %128, %145, %162, %164, %168, %196
%79 = struct $Int (%9 : $Builtin.Word) // user: %80
%80 = enum $Optional<Int>, #Optional.Some!enumelt.1, %79 : $Int // user: %81
br bb4(%76 : $Builtin.Word, %80 : $Optional<Int>) // id: %81
bb4(%82 : $Builtin.Word, %83 : $Optional<Int>): // Preds: bb3 bb8
%84 = unchecked_enum_data %83 : $Optional<Int>, #Optional.Some!enumelt.1 // user: %94
%85 = alloc_stack $Bool // users: %176, %180, %184
%86 = load %6 : $*Optional<Builtin.NativeObject> // users: %89, %122
%87 = load %8 : $*@callee_owned (@out Bool, @in Int) -> () // users: %175, %176
%88 = alloc_stack $Int // users: %174, %176, %177
%89 = unchecked_ref_bit_cast %86 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %90
%90 = enum_is_tag $Builtin.Int1, %89 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %91
%91 = apply %18(%90, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %92
cond_fail %91 : $Builtin.Int1 // id: %92
%93 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %95
%94 = struct_extract %84 : $Int, #Int.value // users: %95, %136, %142, %142, %145, %148, %172
%95 = apply %93(%94, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %138
%96 = metatype $@thick HeapObject.Type // user: %97
%97 = apply %11<HeapObject>(%96) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %101
%98 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %100, %157
%99 = metatype $@thick _ArrayBody.Type // users: %100, %151
%100 = apply %98<_ArrayBody>(%99) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %101, %108
%101 = apply %77(%97, %100, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %102, %103
%102 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 0 // user: %106
%103 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 1 // user: %104
cond_fail %103 : $Builtin.Int1 // id: %104
%105 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %106, %108, %162, %164
%106 = apply %105(%102, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %107
%107 = tuple_extract %106 : $(Builtin.Word, Builtin.Int1), 0 // user: %114
%108 = apply %105(%100, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %109
%109 = tuple_extract %108 : $(Builtin.Word, Builtin.Int1), 0 // user: %112
%110 = integer_literal $Builtin.Word, -1 // users: %112, %166
%111 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %112, %166
%112 = apply %111(%109, %110) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %114
%113 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %114, %167
%114 = apply %113(%107, %112) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %128, %152
%115 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %116
%116 = apply %11<HeapBufferStorage<_ArrayBody, Int>?>(%115) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %119
%117 = metatype $@thick Builtin.NativeObject.Type // user: %118
%118 = apply %11<Builtin.NativeObject>(%117) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %119
%119 = apply %16(%116, %118) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %120
%120 = apply %18(%119, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %121
cond_fail %120 : $Builtin.Int1 // id: %121
%122 = unchecked_ref_bit_cast %86 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %123
%123 = ref_to_raw_pointer %122 : $Builtin.NativeObject to $Builtin.RawPointer // users: %130, %170
%124 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %126
%125 = metatype $@thick Int8.Type // user: %126
%126 = apply %124<Int8>(%125) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %128, %168
%127 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %128, %168
%128 = apply %127(%114, %126, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %129
%129 = tuple_extract %128 : $(Builtin.Word, Builtin.Int1), 0 // user: %130
%130 = index_raw_pointer %123 : $Builtin.RawPointer, %129 : $Builtin.Word // user: %131
%131 = pointer_to_address %130 : $Builtin.RawPointer to $*_ArrayBody // user: %132
%132 = struct_element_addr %131 : $*_ArrayBody, #_ArrayBody.count // user: %133
%133 = struct_element_addr %132 : $*Int, #Int.value // user: %134
%134 = load %133 : $*Builtin.Word // user: %136
%135 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %136
%136 = apply %135(%94, %134) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %138
%137 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %138
%138 = apply %137(%95, %136) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %139
%139 = apply %18(%138, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %140
cond_fail %139 : $Builtin.Int1 // id: %140
%141 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %142
%142 = apply %141(%94, %94) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %143
%143 = apply %18(%142, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %144
cond_fail %143 : $Builtin.Int1 // id: %144
%145 = apply %77(%94, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %146
%146 = tuple_extract %145 : $(Builtin.Word, Builtin.Int1), 0 // user: %148
%147 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %148
%148 = apply %147(%146, %94) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %149
%149 = apply %18(%148, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %150
cond_fail %149 : $Builtin.Int1 // id: %150
%151 = apply %11<_ArrayBody>(%99) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %152
%152 = apply %77(%114, %151, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %153, %154
%153 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 0 // user: %158
%154 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 1 // user: %155
cond_fail %154 : $Builtin.Int1 // id: %155
%156 = metatype $@thick Int.Type // user: %157
%157 = apply %98<Int>(%156) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %158, %164
%158 = apply %77(%153, %157, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %159, %160
%159 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 0 // user: %162
%160 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 1 // user: %161
cond_fail %160 : $Builtin.Int1 // id: %161
%162 = apply %105(%159, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %163
%163 = tuple_extract %162 : $(Builtin.Word, Builtin.Int1), 0 // user: %167
%164 = apply %105(%157, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %165
%165 = tuple_extract %164 : $(Builtin.Word, Builtin.Int1), 0 // user: %166
%166 = apply %111(%165, %110) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %167
%167 = apply %113(%163, %166) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %168
%168 = apply %127(%167, %126, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %169
%169 = tuple_extract %168 : $(Builtin.Word, Builtin.Int1), 0 // user: %170
%170 = index_raw_pointer %123 : $Builtin.RawPointer, %169 : $Builtin.Word // user: %171
%171 = pointer_to_address %170 : $Builtin.RawPointer to $*Int // user: %172
%172 = index_addr %171 : $*Int, %94 : $Builtin.Word // user: %173
%173 = load %172 : $*Int // user: %174
store %173 to %88#1 : $*Int // id: %174
strong_retain %87 : $@callee_owned (@out Bool, @in Int) -> () // id: %175
%176 = apply %87(%85#1, %88#1) : $@callee_owned (@out Bool, @in Int) -> ()
dealloc_stack %88#0 : $*@local_storage Int // id: %177
%178 = struct_element_addr %2 : $*Bool, #Bool.value // user: %179
%179 = load %178 : $*Builtin.Int1 // user: %183
%180 = struct_element_addr %85#1 : $*Bool, #Bool.value // user: %181
%181 = load %180 : $*Builtin.Int1 // user: %183
%182 = builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %183
%183 = apply %182(%181, %179) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %185
dealloc_stack %85#0 : $*@local_storage Bool // id: %184
cond_br %183, bb5, bb7 // id: %185
bb5: // Preds: bb4
store %83 to %0 : $*Optional<Int> // id: %186
br bb6 // id: %187
bb6: // Preds: bb5 bb9
%188 = load %6 : $*Optional<Builtin.NativeObject> // user: %190
%189 = load %8 : $*@callee_owned (@out Bool, @in Int) -> () // user: %191
release_value %188 : $Optional<Builtin.NativeObject> // id: %190
strong_release %189 : $@callee_owned (@out Bool, @in Int) -> () // id: %191
%192 = tuple () // user: %193
return %192 : $() // id: %193
bb7: // Preds: bb4
%194 = apply %16(%82, %75) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %195
cond_br %194, bb9, bb8 // id: %195
bb8: // Preds: bb7
%196 = apply %77(%82, %76, %78) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %197
%197 = tuple_extract %196 : $(Builtin.Word, Builtin.Int1), 0 // user: %200
%198 = struct $Int (%82 : $Builtin.Word) // user: %199
%199 = enum $Optional<Int>, #Optional.Some!enumelt.1, %198 : $Int // user: %200
br bb4(%197 : $Builtin.Word, %199 : $Optional<Int>) // id: %200
bb9: // Preds: bb1 bb2 bb7
%201 = enum $Optional<Int>, #Optional.None!enumelt // user: %202
store %201 to %0 : $*Optional<Int> // id: %202
br bb6 // id: %203
}
// specialization <Swift.LazyForwardCollection<Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool>> with Swift.LazyForwardCollection<Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool>> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index>
sil shared specialization <Swift.LazyForwardCollection<Swift.MapCollectionView<[Swift.Int], Swift.Bool>> with Swift.LazyForwardCollection<Swift.MapCollectionView<[Swift.Int], Swift.Bool>> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.indices <A : Swift.CollectionType>(A) -> Swift.Range<A.Index> : $@thin (@out Range<Int>, @in LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Range<Int>, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %3, %6
%3 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %4
%4 = struct_element_addr %3 : $*Array<Int>, #Array._buffer // user: %5
%5 = struct_element_addr %4 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %8, %76
%6 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // user: %77
%7 = integer_literal $Builtin.Word, 0 // users: %73, %83
%8 = load %5 : $*Optional<Builtin.NativeObject> // users: %25, %57, %82
%9 = integer_literal $Builtin.Int1, -1 // users: %18, %23, %34, %55
%10 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %12, %14, %21, %29, %51, %53
%11 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %12
%12 = apply %10<Builtin.NativeObject?>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %14
%14 = apply %10<_ContiguousArrayStorage<Int>?>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %22
%15 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %16, %22, %54
%16 = apply %15(%12, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
%17 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %18, %23, %55
%18 = apply %17(%16, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %21
%21 = apply %10<HeapBuffer<_ArrayBody, Int>>(%20) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %22
%22 = apply %15(%14, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %23
%23 = apply %17(%22, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %24
cond_fail %23 : $Builtin.Int1 // id: %24
%25 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %26
%26 = enum_is_tag $Builtin.Int1, %25 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %27
cond_br %26, bb1, bb3 // id: %27
bb1: // Preds: bb0
%28 = metatype $@thick HeapObject.Type // user: %29
%29 = apply %10<HeapObject>(%28) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %34
%30 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %32
%31 = metatype $@thick _ArrayBody.Type // user: %32
%32 = apply %30<_ArrayBody>(%31) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %34, %43
%33 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %34
%34 = apply %33(%29, %32, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %35, %36
%35 = tuple_extract %34 : $(Builtin.Word, Builtin.Int1), 0 // user: %41
%36 = tuple_extract %34 : $(Builtin.Word, Builtin.Int1), 1 // user: %37
cond_fail %36 : $Builtin.Int1 // id: %37
%38 = integer_literal $Builtin.Word, 1 // users: %41, %43
%39 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %41, %43
%40 = integer_literal $Builtin.Int1, 0 // users: %41, %43, %63
%41 = apply %39(%35, %38, %40) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %42
%42 = tuple_extract %41 : $(Builtin.Word, Builtin.Int1), 0 // user: %49
%43 = apply %39(%32, %38, %40) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %44
%44 = tuple_extract %43 : $(Builtin.Word, Builtin.Int1), 0 // user: %47
%45 = integer_literal $Builtin.Word, -1 // user: %47
%46 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %47
%47 = apply %46(%44, %45) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %49
%48 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %49
%49 = apply %48(%42, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %63
%50 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %51
%51 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%50) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %54
%52 = metatype $@thick Builtin.NativeObject.Type // user: %53
%53 = apply %10<Builtin.NativeObject>(%52) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %54
%54 = apply %15(%51, %53) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %55
%55 = apply %17(%54, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %56
cond_fail %55 : $Builtin.Int1 // id: %56
%57 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %58
%58 = ref_to_raw_pointer %57 : $Builtin.NativeObject to $Builtin.RawPointer // user: %65
%59 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %61
%60 = metatype $@thick Int8.Type // user: %61
%61 = apply %59<Int8>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %63
%62 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %63
%63 = apply %62(%49, %61, %40) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %64
%64 = tuple_extract %63 : $(Builtin.Word, Builtin.Int1), 0 // user: %65
%65 = index_raw_pointer %58 : $Builtin.RawPointer, %64 : $Builtin.Word // user: %66
%66 = pointer_to_address %65 : $Builtin.RawPointer to $*_ArrayBody // user: %67
%67 = struct_element_addr %66 : $*_ArrayBody, #_ArrayBody.count // user: %68
%68 = struct_element_addr %67 : $*Int, #Int.value // user: %69
%69 = load %68 : $*Builtin.Word // user: %70
br bb2(%69 : $Builtin.Word) // id: %70
bb2(%71 : $Builtin.Word): // Preds: bb1 bb3
%72 = struct $Int (%71 : $Builtin.Word) // user: %74
%73 = struct $Int (%7 : $Builtin.Word) // user: %74
%74 = struct $Range<Int> (%73 : $Int, %72 : $Int) // user: %75
store %74 to %0 : $*Range<Int> // id: %75
%76 = load %5 : $*Optional<Builtin.NativeObject> // user: %78
%77 = load %6 : $*@callee_owned (@out Bool, @in Int) -> () // user: %79
release_value %76 : $Optional<Builtin.NativeObject> // id: %78
strong_release %77 : $@callee_owned (@out Bool, @in Int) -> () // id: %79
%80 = tuple () // user: %81
return %80 : $() // id: %81
bb3: // Preds: bb0
retain_value %8 : $Optional<Builtin.NativeObject> // id: %82
br bb2(%7 : $Builtin.Word) // id: %83
}
// protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType : $@cc(witness_method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>.Index, @inout LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Index, %1 : $*LazyForwardCollection<S>):
%2 = alloc_stack $LazyForwardCollection<S> // users: %3, %5, %6
copy_addr %1 to [initialization] %2#1 : $*LazyForwardCollection<S> // id: %3
// function_ref Swift.LazyForwardCollection.startIndex.getter : A.Index
%4 = function_ref Swift.LazyForwardCollection.startIndex.getter : A.Index : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %5
%5 = apply %4<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %2#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %7
dealloc_stack %2#0 : $*@local_storage LazyForwardCollection<S> // id: %6
return %5 : $() // id: %7
}
// protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType : $@cc(witness_method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>.Index, @inout LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Index, %1 : $*LazyForwardCollection<S>):
%2 = alloc_stack $LazyForwardCollection<S> // users: %3, %5, %6
copy_addr %1 to [initialization] %2#1 : $*LazyForwardCollection<S> // id: %3
// function_ref Swift.LazyForwardCollection.endIndex.getter : A.Index
%4 = function_ref Swift.LazyForwardCollection.endIndex.getter : A.Index : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %5
%5 = apply %4<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %2#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %7
dealloc_stack %2#0 : $*@local_storage LazyForwardCollection<S> // id: %6
return %5 : $() // id: %7
}
// protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.LazyForwardCollection : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.LazyForwardCollection : Swift._CollectionType : $@cc(witness_method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>._Element, @in LazyForwardCollection<S>.Index, @inout LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Generator.Element, %1 : $*S.Index, %2 : $*LazyForwardCollection<S>):
%3 = alloc_stack $LazyForwardCollection<S> // users: %4, %6, %7
copy_addr %2 to [initialization] %3#1 : $*LazyForwardCollection<S> // id: %4
// function_ref Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element
%5 = function_ref Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %6
%6 = apply %5<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %8
dealloc_stack %3#0 : $*@local_storage LazyForwardCollection<S> // id: %7
return %6 : $() // id: %8
}
// specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A>
sil shared [transparent] specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.init <A : Swift.ForwardIndexType>(Swift.Range<A>.Type)(start : A, end : A) -> Swift.Range<A> : $@thin (@out Range<Int>, @in Int, @in Int, @thin Range<Int>.Type) -> () {
bb0(%0 : $*Range<Int>, %1 : $*Int, %2 : $*Int, %3 : $@thin Range<Int>.Type):
%4 = load %1 : $*Int // user: %6
%5 = load %2 : $*Int // user: %6
%6 = struct $Range<Int> (%4 : $Int, %5 : $Int) // user: %7
store %6 to %0 : $*Range<Int> // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A>
sil shared specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A> : $@cc(method) @thin (@out RangeGenerator<Int>, @in Range<Int>) -> () {
bb0(%0 : $*RangeGenerator<Int>, %1 : $*Range<Int>):
%2 = struct_element_addr %1 : $*Range<Int>, #Range._startIndex // user: %3
%3 = struct_element_addr %2 : $*Int, #Int.value // user: %4
%4 = load %3 : $*Builtin.Word // user: %8
%5 = struct_element_addr %1 : $*Range<Int>, #Range._endIndex // user: %6
%6 = struct_element_addr %5 : $*Int, #Int.value // user: %7
%7 = load %6 : $*Builtin.Word // user: %9
%8 = struct $Int (%4 : $Builtin.Word) // user: %10
%9 = struct $Int (%7 : $Builtin.Word) // user: %10
%10 = struct $RangeGenerator<Int> (%8 : $Int, %9 : $Int) // user: %11
store %10 to %0 : $*RangeGenerator<Int> // id: %11
%12 = tuple () // user: %13
return %12 : $() // id: %13
}
// specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A>
sil shared [transparent] specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.init <A : Swift.ForwardIndexType>(Swift.RangeGenerator<A>.Type)(Swift.Range<A>) -> Swift.RangeGenerator<A> : $@thin (@out RangeGenerator<Int>, @in Range<Int>, @thin RangeGenerator<Int>.Type) -> () {
bb0(%0 : $*RangeGenerator<Int>, %1 : $*Range<Int>, %2 : $@thin RangeGenerator<Int>.Type):
%3 = alloc_stack $Range<Int> // users: %5, %8, %11
%4 = load %1 : $*Range<Int> // user: %5
store %4 to %3#1 : $*Range<Int> // id: %5
// function_ref Swift.Range.startIndex.getter : A
%6 = function_ref Swift.Range.startIndex.getter : A : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> () // user: %8
%7 = alloc_stack $Int // users: %8, %9, %10
%8 = apply %6<Int, Int, Int, Int>(%7#1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> ()
%9 = load %7#1 : $*Int // user: %21
dealloc_stack %7#0 : $*@local_storage Int // id: %10
dealloc_stack %3#0 : $*@local_storage Range<Int> // id: %11
%12 = alloc_stack $Range<Int> // users: %14, %17, %20
%13 = load %1 : $*Range<Int> // user: %14
store %13 to %12#1 : $*Range<Int> // id: %14
// function_ref Swift.Range.endIndex.getter : A
%15 = function_ref Swift.Range.endIndex.getter : A : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> () // user: %17
%16 = alloc_stack $Int // users: %17, %18, %19
%17 = apply %15<Int, Int, Int, Int>(%16#1, %12#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, @in Range<τ_0_0>) -> ()
%18 = load %16#1 : $*Int // user: %21
dealloc_stack %16#0 : $*@local_storage Int // id: %19
dealloc_stack %12#0 : $*@local_storage Range<Int> // id: %20
%21 = struct $RangeGenerator<Int> (%9 : $Int, %18 : $Int) // user: %22
store %21 to %0 : $*RangeGenerator<Int> // id: %22
%23 = tuple () // user: %24
return %23 : $() // id: %24
}
// specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> Swift.Optional<A>
sil shared specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> A? : $@cc(method) @thin (@out Optional<Int>, @inout RangeGenerator<Int>) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*RangeGenerator<Int>):
%2 = struct_element_addr %1 : $*RangeGenerator<Int>, #RangeGenerator.startIndex // users: %3, %22
%3 = struct_element_addr %2 : $*Int, #Int.value // user: %4
%4 = load %3 : $*Builtin.Word // users: %9, %19, %23
%5 = struct_element_addr %1 : $*RangeGenerator<Int>, #RangeGenerator.endIndex // user: %6
%6 = struct_element_addr %5 : $*Int, #Int.value // user: %7
%7 = load %6 : $*Builtin.Word // user: %9
%8 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%9 = apply %8(%4, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %10
cond_br %9, bb1, bb3 // id: %10
bb1: // Preds: bb0
%11 = enum $Optional<Int>, #Optional.None!enumelt // user: %12
store %11 to %0 : $*Optional<Int> // id: %12
br bb2 // id: %13
bb2: // Preds: bb1 bb3
%14 = tuple () // user: %15
return %14 : $() // id: %15
bb3: // Preds: bb0
%16 = integer_literal $Builtin.Word, 1 // user: %19
%17 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%18 = integer_literal $Builtin.Int1, 0 // user: %19
%19 = apply %17(%4, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %20
%20 = tuple_extract %19 : $(Builtin.Word, Builtin.Int1), 0 // user: %21
%21 = struct $Int (%20 : $Builtin.Word) // user: %22
store %21 to %2 : $*Int // id: %22
%23 = struct $Int (%4 : $Builtin.Word) // user: %24
%24 = enum $Optional<Int>, #Optional.Some!enumelt.1, %23 : $Int // user: %25
store %24 to %0 : $*Optional<Int> // id: %25
br bb2 // id: %26
}
// specialization <Swift.Int with Swift.Int : Swift._Incrementable> of Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
sil shared [transparent] specialization <Swift.Int with Swift.Int : Swift._Incrementable> of Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin (@out Int, @inout Int) -> () {
bb0(%0 : $*Int, %1 : $*Int):
%2 = load %1 : $*Int // users: %3, %11
%3 = struct_extract %2 : $Int, #Int.value // user: %7
%4 = integer_literal $Builtin.Word, 1 // user: %7
%5 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %7
%6 = integer_literal $Builtin.Int1, 0 // user: %7
%7 = apply %5(%3, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %8
%8 = tuple_extract %7 : $(Builtin.Word, Builtin.Int1), 0 // user: %9
%9 = struct $Int (%8 : $Builtin.Word) // user: %10
store %9 to %1 : $*Int // id: %10
store %2 to %0 : $*Int // id: %11
%12 = tuple () // user: %13
return %12 : $() // id: %13
}
// specialization <Swift.Int> of Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.Int> of Swift._injectValueIntoOptional <A>(A) -> A? : $@thin (@out Optional<Int>, @in Int) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*Int):
// function_ref Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
%2 = function_ref Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> () // user: %7
%3 = metatype $@thin Optional<Int>.Type // user: %7
%4 = alloc_stack $Int // users: %6, %7, %8
%5 = load %1 : $*Int // user: %6
store %5 to %4#1 : $*Int // id: %6
%7 = apply [transparent] %2<Int>(%0, %4#1, %3) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage Int // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.CollectionType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of indexof.v2_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> Swift.Optional<A.Index>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.CollectionType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of indexof.v2_index_of <A : Swift.CollectionType>(A, (A.Generator.Element) -> Swift.Bool) -> A.Index? : $@thin (@out Optional<Int>, @in Array<Int>, @owned @callee_owned (@in Int) -> Bool) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*Array<Int>, %2 : $@callee_owned (@in Int) -> Bool):
%3 = struct_element_addr %1 : $*Array<Int>, #Array._buffer // user: %4
%4 = struct_element_addr %3 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %5, %143
%5 = load %4 : $*Optional<Builtin.NativeObject> // users: %18, %24, %26, %58, %71, %75, %140
%6 = integer_literal $Builtin.Word, 0 // users: %72, %74, %74, %87, %152
%7 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %14, %21, %55, %72, %150, %152
%8 = integer_literal $Builtin.Int1, -1 // users: %16, %22, %35, %56, %84, %93, %97, %101, %104, %110, %127
%9 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %11, %13, %20, %30, %52, %54, %103
%10 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %11
%11 = apply %9<Builtin.NativeObject?>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %14
%12 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %13
%13 = apply %9<_ContiguousArrayStorage<Int>?>(%12) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %14, %21
%14 = apply %7(%11, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
%15 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %16, %22, %56, %84, %93, %97, %101
%16 = apply %15(%14, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
cond_fail %16 : $Builtin.Int1 // id: %17
%18 = unchecked_ref_bit_cast %5 : $Optional<Builtin.NativeObject> to $Optional<_ContiguousArrayStorage<Int>> // users: %27, %153
%19 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %20
%20 = apply %9<HeapBuffer<_ArrayBody, Int>>(%19) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%21 = apply %7(%13, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%22 = apply %15(%21, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = unchecked_ref_bit_cast %5 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %25, %83, %147
%25 = enum_is_tag $Builtin.Int1, %24 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %28
retain_value %5 : $Optional<Builtin.NativeObject> // id: %26
retain_value %18 : $Optional<_ContiguousArrayStorage<Int>> // id: %27
cond_br %25, bb1, bb3 // id: %28
bb1: // Preds: bb0
%29 = metatype $@thick HeapObject.Type // user: %30
%30 = apply %9<HeapObject>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %35
%31 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %33, %109
%32 = metatype $@thick _ArrayBody.Type // users: %33, %103
%33 = apply %31<_ArrayBody>(%32) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %44
%34 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %35, %81, %104, %110, %127
%35 = apply %34(%30, %33, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %36, %37
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %42
%37 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = integer_literal $Builtin.Word, 1 // users: %42, %44, %81, %114, %116, %127
%40 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %44, %114, %116
%41 = integer_literal $Builtin.Int1, 0 // users: %42, %44, %64, %81, %114, %116, %120
%42 = apply %40(%36, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %50
%44 = apply %40(%33, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %45
%45 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%46 = integer_literal $Builtin.Word, -1 // users: %48, %118
%47 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %48, %118
%48 = apply %47(%45, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%49 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %50, %119
%50 = apply %49(%43, %48) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %64, %104
%51 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %52
%52 = apply %9<HeapBufferStorage<_ArrayBody, Int>?>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%53 = metatype $@thick Builtin.NativeObject.Type // user: %54
%54 = apply %9<Builtin.NativeObject>(%53) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%55 = apply %7(%52, %54) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %56
%56 = apply %15(%55, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %57
cond_fail %56 : $Builtin.Int1 // id: %57
%58 = unchecked_ref_bit_cast %5 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %59
%59 = ref_to_raw_pointer %58 : $Builtin.NativeObject to $Builtin.RawPointer // users: %66, %122
%60 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%61 = metatype $@thick Int8.Type // user: %62
%62 = apply %60<Int8>(%61) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %64, %120
%63 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %64, %120
%64 = apply %63(%50, %62, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = tuple_extract %64 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%66 = index_raw_pointer %59 : $Builtin.RawPointer, %65 : $Builtin.Word // user: %67
%67 = pointer_to_address %66 : $Builtin.RawPointer to $*_ArrayBody // user: %68
%68 = struct_element_addr %67 : $*_ArrayBody, #_ArrayBody.count // user: %69
%69 = struct_element_addr %68 : $*Int, #Int.value // users: %70, %88, %149
%70 = load %69 : $*Builtin.Word // user: %72
release_value %5 : $Optional<Builtin.NativeObject> // id: %71
%72 = apply %7(%6, %70) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %73
cond_br %72, bb3, bb2 // id: %73
bb2: // Preds: bb1
br bb4(%6 : $Builtin.Word, %6 : $Builtin.Word) // id: %74
bb3: // Preds: bb0 bb1 bb8 bb9
release_value %5 : $Optional<Builtin.NativeObject> // id: %75
%76 = enum $Optional<Int>, #Optional.None!enumelt // user: %77
store %76 to %0 : $*Optional<Int> // id: %77
br bb6 // id: %78
bb4(%79 : $Builtin.Word, %80 : $Builtin.Word): // Preds: bb2 bb8 bb9
%81 = apply %34(%79, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %82
%82 = tuple_extract %81 : $(Builtin.Word, Builtin.Int1), 0 // users: %100, %150, %151, %152, %154
%83 = enum_is_tag $Builtin.Int1, %24 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %84
%84 = apply %15(%83, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %85
cond_fail %84 : $Builtin.Int1 // id: %85
%86 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %87
%87 = apply %86(%79, %6) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %92
%88 = load %69 : $*Builtin.Word // user: %90
%89 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %90
%90 = apply %89(%79, %88) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %92
%91 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %92
%92 = apply %91(%87, %90) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %93
%93 = apply %15(%92, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %94
cond_fail %93 : $Builtin.Int1 // id: %94
%95 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %96
%96 = apply %95(%79, %79) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
%97 = apply %15(%96, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %100
%100 = apply %99(%82, %79) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %101
%101 = apply %15(%100, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %102
cond_fail %101 : $Builtin.Int1 // id: %102
%103 = apply %9<_ArrayBody>(%32) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %104
%104 = apply %34(%50, %103, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %105, %106
%105 = tuple_extract %104 : $(Builtin.Word, Builtin.Int1), 0 // user: %110
%106 = tuple_extract %104 : $(Builtin.Word, Builtin.Int1), 1 // user: %107
cond_fail %106 : $Builtin.Int1 // id: %107
%108 = metatype $@thick Int.Type // user: %109
%109 = apply %31<Int>(%108) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %110, %116
%110 = apply %34(%105, %109, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %111, %112
%111 = tuple_extract %110 : $(Builtin.Word, Builtin.Int1), 0 // user: %114
%112 = tuple_extract %110 : $(Builtin.Word, Builtin.Int1), 1 // user: %113
cond_fail %112 : $Builtin.Int1 // id: %113
%114 = apply %40(%111, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %115
%115 = tuple_extract %114 : $(Builtin.Word, Builtin.Int1), 0 // user: %119
%116 = apply %40(%109, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %117
%117 = tuple_extract %116 : $(Builtin.Word, Builtin.Int1), 0 // user: %118
%118 = apply %47(%117, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %119
%119 = apply %49(%115, %118) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %120
%120 = apply %63(%119, %62, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %121
%121 = tuple_extract %120 : $(Builtin.Word, Builtin.Int1), 0 // user: %122
%122 = index_raw_pointer %59 : $Builtin.RawPointer, %121 : $Builtin.Word // user: %123
%123 = pointer_to_address %122 : $Builtin.RawPointer to $*Int // user: %124
%124 = index_addr %123 : $*Int, %79 : $Builtin.Word // user: %125
%125 = load %124 : $*Int // user: %132
%126 = struct $Int (%80 : $Builtin.Word) // user: %138
%127 = apply %34(%80, %39, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %128, %129
%128 = tuple_extract %127 : $(Builtin.Word, Builtin.Int1), 0 // users: %151, %154
%129 = tuple_extract %127 : $(Builtin.Word, Builtin.Int1), 1 // user: %130
cond_fail %129 : $Builtin.Int1 // id: %130
%131 = alloc_stack $Int // users: %132, %134, %136
store %125 to %131#1 : $*Int // id: %132
strong_retain %2 : $@callee_owned (@in Int) -> Bool // id: %133
%134 = apply %2(%131#1) : $@callee_owned (@in Int) -> Bool // user: %135
%135 = struct_extract %134 : $Bool, #Bool.value // user: %137
dealloc_stack %131#0 : $*@local_storage Int // id: %136
cond_br %135, bb5, bb7 // id: %137
bb5: // Preds: bb4
%138 = enum $Optional<Int>, #Optional.Some!enumelt.1, %126 : $Int // user: %139
store %138 to %0 : $*Optional<Int> // id: %139
release_value %5 : $Optional<Builtin.NativeObject> // id: %140
br bb6 // id: %141
bb6: // Preds: bb3 bb5
strong_release %2 : $@callee_owned (@in Int) -> Bool // id: %142
%143 = load %4 : $*Optional<Builtin.NativeObject> // user: %144
release_value %143 : $Optional<Builtin.NativeObject> // id: %144
%145 = tuple () // user: %146
return %145 : $() // id: %146
bb7: // Preds: bb4
%147 = enum_is_tag $Builtin.Int1, %24 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %148
cond_br %147, bb8, bb9 // id: %148
bb8: // Preds: bb7
%149 = load %69 : $*Builtin.Word // user: %150
%150 = apply %7(%82, %149) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %151
cond_br %150, bb3, bb4(%82 : $Builtin.Word, %128 : $Builtin.Word) // id: %151
bb9: // Preds: bb7
%152 = apply %7(%82, %6) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %154
retain_value %18 : $Optional<_ContiguousArrayStorage<Int>> // id: %153
cond_br %152, bb3, bb4(%82 : $Builtin.Word, %128 : $Builtin.Word) // id: %154
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.SequenceType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int> of Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.SequenceType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int> of Swift.enumerate <A : Swift.SequenceType>(A) -> Swift.EnumerateSequence<A> : $@thin (@out EnumerateSequence<Array<Int>>, @in Array<Int>) -> () {
bb0(%0 : $*EnumerateSequence<Array<Int>>, %1 : $*Array<Int>):
%2 = load %1 : $*Array<Int> // user: %3
%3 = struct $EnumerateSequence<Array<Int>> (%2 : $Array<Int>) // user: %4
store %3 to %0 : $*EnumerateSequence<Array<Int>> // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.SequenceType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.SequenceType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateSequence.init <A : Swift.SequenceType>(Swift.EnumerateSequence<A>.Type)(A) -> Swift.EnumerateSequence<A> : $@thin (@out EnumerateSequence<Array<Int>>, @in Array<Int>, @thin EnumerateSequence<Array<Int>>.Type) -> () {
bb0(%0 : $*EnumerateSequence<Array<Int>>, %1 : $*Array<Int>, %2 : $@thin EnumerateSequence<Array<Int>>.Type):
%3 = load %1 : $*Array<Int> // user: %4
%4 = struct $EnumerateSequence<Array<Int>> (%3 : $Array<Int>) // user: %5
store %4 to %0 : $*EnumerateSequence<Array<Int>> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift.SequenceType, Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift.SequenceType, Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateSequence.generate <A : Swift.SequenceType>(Swift.EnumerateSequence<A>)() -> Swift.EnumerateGenerator<A.Generator> : $@cc(method) @thin (@out EnumerateGenerator<IndexingGenerator<Array<Int>>>, @in EnumerateSequence<Array<Int>>) -> () {
bb0(%0 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>>, %1 : $*EnumerateSequence<Array<Int>>):
%2 = struct_element_addr %1 : $*EnumerateSequence<Array<Int>>, #EnumerateSequence.base // user: %3
%3 = load %2 : $*Array<Int> // user: %6
%4 = integer_literal $Builtin.Word, 0 // user: %5
%5 = struct $Int (%4 : $Builtin.Word) // users: %6, %7
%6 = struct $IndexingGenerator<Array<Int>> (%3 : $Array<Int>, %5 : $Int) // user: %7
%7 = struct $EnumerateGenerator<IndexingGenerator<Array<Int>>> (%6 : $IndexingGenerator<Array<Int>>, %5 : $Int) // user: %8
store %7 to %0 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A>
sil shared specialization <Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateGenerator.init <A : Swift.GeneratorType>(Swift.EnumerateGenerator<A>.Type)(A) -> Swift.EnumerateGenerator<A> : $@thin (@out EnumerateGenerator<IndexingGenerator<Array<Int>>>, @in IndexingGenerator<Array<Int>>, @thin EnumerateGenerator<IndexingGenerator<Array<Int>>>.Type) -> () {
bb0(%0 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>>, %1 : $*IndexingGenerator<Array<Int>>, %2 : $@thin EnumerateGenerator<IndexingGenerator<Array<Int>>>.Type):
%3 = load %1 : $*IndexingGenerator<Array<Int>> // user: %6
%4 = integer_literal $Builtin.Word, 0 // user: %5
%5 = struct $Int (%4 : $Builtin.Word) // user: %6
%6 = struct $EnumerateGenerator<IndexingGenerator<Array<Int>>> (%3 : $IndexingGenerator<Array<Int>>, %5 : $Int) // user: %7
store %6 to %0 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>> // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// specialization <Swift.IndexingGenerator<Swift.Array<Swift.Int>> with Swift.IndexingGenerator<Swift.Array<Swift.Int>> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> Swift.Optional<(index : Swift.Int, element : A.Element)>
sil shared specialization <Swift.IndexingGenerator<[Swift.Int]> with Swift.IndexingGenerator<[Swift.Int]> : Swift.GeneratorType, Swift.Int> of Swift.EnumerateGenerator.next <A : Swift.GeneratorType>(inout Swift.EnumerateGenerator<A>)() -> (index : Swift.Int, element : A.Element)? : $@cc(method) @thin (@out Optional<(index: Int, element: Int)>, @inout EnumerateGenerator<IndexingGenerator<Array<Int>>>) -> () {
bb0(%0 : $*Optional<(index: Int, element: Int)>, %1 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>>):
%2 = struct_element_addr %1 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>>, #EnumerateGenerator.base // users: %3, %6
%3 = struct_element_addr %2 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._position // users: %4, %88
%4 = struct_element_addr %3 : $*Int, #Int.value // users: %5, %81
%5 = load %4 : $*Builtin.Word // users: %72, %75
%6 = struct_element_addr %2 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._elements // user: %7
%7 = struct_element_addr %6 : $*Array<Int>, #Array._buffer // user: %8
%8 = struct_element_addr %7 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %9, %89
%9 = load %8 : $*Optional<Builtin.NativeObject> // users: %21, %27, %59
%10 = integer_literal $Builtin.Int1, -1 // users: %19, %25, %36, %57, %92, %102, %121, %140, %144, %148, %151, %157, %176
%11 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %13, %15, %23, %31, %53, %55, %98, %117, %119, %150
%12 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %13
%13 = apply %11<Builtin.NativeObject?>(%12) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %17
%14 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %15
%15 = apply %11<_ContiguousArrayStorage<Int>?>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %17, %24
%16 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %17, %24, %56, %72, %75, %120
%17 = apply %16(%13, %15) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
%18 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %19, %25, %57, %92, %121, %140, %144, %148
%19 = apply %18(%17, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %20
cond_fail %19 : $Builtin.Int1 // id: %20
%21 = unchecked_ref_bit_cast %9 : $Optional<Builtin.NativeObject> to $Optional<_ContiguousArrayStorage<Int>> // user: %76
%22 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %23
%23 = apply %11<HeapBuffer<_ArrayBody, Int>>(%22) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %24
%24 = apply %16(%15, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
%25 = apply %18(%24, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %26
cond_fail %25 : $Builtin.Int1 // id: %26
%27 = unchecked_ref_bit_cast %9 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %28
%28 = enum_is_tag $Builtin.Int1, %27 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %29
cond_br %28, bb1, bb2 // id: %29
bb1: // Preds: bb0
%30 = metatype $@thick HeapObject.Type // user: %31
%31 = apply %11<HeapObject>(%30) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %36
%32 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %34
%33 = metatype $@thick _ArrayBody.Type // user: %34
%34 = apply %32<_ArrayBody>(%33) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %36, %45
%35 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %36
%36 = apply %35(%31, %34, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %37, %38
%37 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 0 // user: %43
%38 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 1 // user: %39
cond_fail %38 : $Builtin.Int1 // id: %39
%40 = integer_literal $Builtin.Word, 1 // users: %43, %45
%41 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %43, %45
%42 = integer_literal $Builtin.Int1, 0 // users: %43, %45, %65
%43 = apply %41(%37, %40, %42) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %44
%44 = tuple_extract %43 : $(Builtin.Word, Builtin.Int1), 0 // user: %51
%45 = apply %41(%34, %40, %42) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %46
%46 = tuple_extract %45 : $(Builtin.Word, Builtin.Int1), 0 // user: %49
%47 = integer_literal $Builtin.Word, -1 // user: %49
%48 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %49
%49 = apply %48(%46, %47) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %51
%50 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %51
%51 = apply %50(%44, %49) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %65
%52 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %53
%53 = apply %11<HeapBufferStorage<_ArrayBody, Int>?>(%52) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %56
%54 = metatype $@thick Builtin.NativeObject.Type // user: %55
%55 = apply %11<Builtin.NativeObject>(%54) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %56
%56 = apply %16(%53, %55) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %57
%57 = apply %18(%56, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %58
cond_fail %57 : $Builtin.Int1 // id: %58
%59 = unchecked_ref_bit_cast %9 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %60
%60 = ref_to_raw_pointer %59 : $Builtin.NativeObject to $Builtin.RawPointer // user: %67
%61 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %63
%62 = metatype $@thick Int8.Type // user: %63
%63 = apply %61<Int8>(%62) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %65
%64 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = apply %64(%51, %63, %42) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %66
%66 = tuple_extract %65 : $(Builtin.Word, Builtin.Int1), 0 // user: %67
%67 = index_raw_pointer %60 : $Builtin.RawPointer, %66 : $Builtin.Word // user: %68
%68 = pointer_to_address %67 : $Builtin.RawPointer to $*_ArrayBody // user: %69
%69 = struct_element_addr %68 : $*_ArrayBody, #_ArrayBody.count // user: %70
%70 = struct_element_addr %69 : $*Int, #Int.value // user: %71
%71 = load %70 : $*Builtin.Word // user: %72
%72 = apply %16(%5, %71) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %73
cond_br %72, bb3, bb4 // id: %73
bb2: // Preds: bb0
%74 = integer_literal $Builtin.Word, 0 // user: %75
%75 = apply %16(%5, %74) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %77
retain_value %21 : $Optional<_ContiguousArrayStorage<Int>> // id: %76
cond_br %75, bb3, bb4 // id: %77
bb3: // Preds: bb1 bb2
%78 = enum $Optional<(index: Int, element: Int)>, #Optional.None!enumelt // user: %79
store %78 to %0 : $*Optional<(index: Int, element: Int)> // id: %79
br bb5 // id: %80
bb4: // Preds: bb1 bb2
%81 = load %4 : $*Builtin.Word // users: %85, %96, %137, %143, %143, %147, %171
%82 = integer_literal $Builtin.Word, 1 // users: %85, %107, %109, %161, %163, %176
%83 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %85, %102, %151, %157, %176
%84 = integer_literal $Builtin.Int1, 0 // users: %85, %107, %109, %129, %161, %163, %167
%85 = apply %83(%81, %82, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %86
%86 = tuple_extract %85 : $(Builtin.Word, Builtin.Int1), 0 // users: %87, %147
%87 = struct $Int (%86 : $Builtin.Word) // user: %88
store %87 to %3 : $*Int // id: %88
%89 = load %8 : $*Optional<Builtin.NativeObject> // users: %90, %123
%90 = unchecked_ref_bit_cast %89 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %91
%91 = enum_is_tag $Builtin.Int1, %90 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %92
%92 = apply %18(%91, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %93
cond_fail %92 : $Builtin.Int1 // id: %93
%94 = integer_literal $Builtin.Word, 0 // user: %96
%95 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %96
%96 = apply %95(%81, %94) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %139
%97 = metatype $@thick HeapObject.Type // user: %98
%98 = apply %11<HeapObject>(%97) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %102
%99 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %101, %156
%100 = metatype $@thick _ArrayBody.Type // users: %101, %150
%101 = apply %99<_ArrayBody>(%100) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %102, %109
%102 = apply %83(%98, %101, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %103, %104
%103 = tuple_extract %102 : $(Builtin.Word, Builtin.Int1), 0 // user: %107
%104 = tuple_extract %102 : $(Builtin.Word, Builtin.Int1), 1 // user: %105
cond_fail %104 : $Builtin.Int1 // id: %105
%106 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %107, %109, %161, %163
%107 = apply %106(%103, %82, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %108
%108 = tuple_extract %107 : $(Builtin.Word, Builtin.Int1), 0 // user: %115
%109 = apply %106(%101, %82, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %110
%110 = tuple_extract %109 : $(Builtin.Word, Builtin.Int1), 0 // user: %113
%111 = integer_literal $Builtin.Word, -1 // users: %113, %165
%112 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %113, %165
%113 = apply %112(%110, %111) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %115
%114 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %115, %166
%115 = apply %114(%108, %113) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %129, %151
%116 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %117
%117 = apply %11<HeapBufferStorage<_ArrayBody, Int>?>(%116) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %120
%118 = metatype $@thick Builtin.NativeObject.Type // user: %119
%119 = apply %11<Builtin.NativeObject>(%118) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %120
%120 = apply %16(%117, %119) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %121
%121 = apply %18(%120, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %122
cond_fail %121 : $Builtin.Int1 // id: %122
%123 = unchecked_ref_bit_cast %89 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %124
%124 = ref_to_raw_pointer %123 : $Builtin.NativeObject to $Builtin.RawPointer // users: %131, %169
%125 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %127
%126 = metatype $@thick Int8.Type // user: %127
%127 = apply %125<Int8>(%126) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %129, %167
%128 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %129, %167
%129 = apply %128(%115, %127, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %130
%130 = tuple_extract %129 : $(Builtin.Word, Builtin.Int1), 0 // user: %131
%131 = index_raw_pointer %124 : $Builtin.RawPointer, %130 : $Builtin.Word // user: %132
%132 = pointer_to_address %131 : $Builtin.RawPointer to $*_ArrayBody // user: %133
%133 = struct_element_addr %132 : $*_ArrayBody, #_ArrayBody.count // user: %134
%134 = struct_element_addr %133 : $*Int, #Int.value // user: %135
%135 = load %134 : $*Builtin.Word // user: %137
%136 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %137
%137 = apply %136(%81, %135) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %139
%138 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %139
%139 = apply %138(%96, %137) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %140
%140 = apply %18(%139, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %141
cond_fail %140 : $Builtin.Int1 // id: %141
%142 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %143
%143 = apply %142(%81, %81) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %144
%144 = apply %18(%143, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %145
cond_fail %144 : $Builtin.Int1 // id: %145
%146 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %147
%147 = apply %146(%86, %81) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %148
%148 = apply %18(%147, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %149
cond_fail %148 : $Builtin.Int1 // id: %149
%150 = apply %11<_ArrayBody>(%100) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %151
%151 = apply %83(%115, %150, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %152, %153
%152 = tuple_extract %151 : $(Builtin.Word, Builtin.Int1), 0 // user: %157
%153 = tuple_extract %151 : $(Builtin.Word, Builtin.Int1), 1 // user: %154
cond_fail %153 : $Builtin.Int1 // id: %154
%155 = metatype $@thick Int.Type // user: %156
%156 = apply %99<Int>(%155) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %157, %163
%157 = apply %83(%152, %156, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %158, %159
%158 = tuple_extract %157 : $(Builtin.Word, Builtin.Int1), 0 // user: %161
%159 = tuple_extract %157 : $(Builtin.Word, Builtin.Int1), 1 // user: %160
cond_fail %159 : $Builtin.Int1 // id: %160
%161 = apply %106(%158, %82, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %162
%162 = tuple_extract %161 : $(Builtin.Word, Builtin.Int1), 0 // user: %166
%163 = apply %106(%156, %82, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %164
%164 = tuple_extract %163 : $(Builtin.Word, Builtin.Int1), 0 // user: %165
%165 = apply %112(%164, %111) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %166
%166 = apply %114(%162, %165) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %167
%167 = apply %128(%166, %127, %84) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %168
%168 = tuple_extract %167 : $(Builtin.Word, Builtin.Int1), 0 // user: %169
%169 = index_raw_pointer %124 : $Builtin.RawPointer, %168 : $Builtin.Word // user: %170
%170 = pointer_to_address %169 : $Builtin.RawPointer to $*Int // user: %171
%171 = index_addr %170 : $*Int, %81 : $Builtin.Word // user: %172
%172 = load %171 : $*Int // user: %182
%173 = struct_element_addr %1 : $*EnumerateGenerator<IndexingGenerator<Array<Int>>>, #EnumerateGenerator.count // users: %174, %181
%174 = load %173 : $*Int // users: %175, %182
%175 = struct_extract %174 : $Int, #Int.value // user: %176
%176 = apply %83(%175, %82, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %177, %178
%177 = tuple_extract %176 : $(Builtin.Word, Builtin.Int1), 0 // user: %180
%178 = tuple_extract %176 : $(Builtin.Word, Builtin.Int1), 1 // user: %179
cond_fail %178 : $Builtin.Int1 // id: %179
%180 = struct $Int (%177 : $Builtin.Word) // user: %181
store %180 to %173 : $*Int // id: %181
%182 = tuple $(index: Int, element: Int) (%174, %172) // user: %183
%183 = enum $Optional<(index: Int, element: Int)>, #Optional.Some!enumelt.1, %182 : $(index: Int, element: Int) // user: %184
store %183 to %0 : $*Optional<(index: Int, element: Int)> // id: %184
br bb5 // id: %185
bb5: // Preds: bb3 bb4
%186 = tuple () // user: %187
return %186 : $() // id: %187
}
// specialization <Swift.Int> of Swift.== infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
sil shared specialization <Swift.Int> of Swift.== infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin (@in Optional<Int>, _OptionalNilComparisonType) -> Bool {
bb0(%0 : $*Optional<Int>, %1 : $_OptionalNilComparisonType):
%2 = load %0 : $*Optional<Int> // user: %3
%3 = enum_is_tag $Builtin.Int1, %2 : $Optional<Int>, #Optional.None!enumelt // user: %4
%4 = struct $Bool (%3 : $Builtin.Int1) // user: %5
return %4 : $Bool // id: %5
}
// specialization <Swift.Int> of Swift._preconditionOptionalHasValue <A>(inout Swift.Optional<A>) -> ()
sil shared [transparent] specialization <Swift.Int> of Swift._preconditionOptionalHasValue <A>(inout A?) -> () : $@thin (@inout Optional<Int>) -> () {
bb0(%0 : $*Optional<Int>):
%1 = integer_literal $Builtin.Int1, -1 // user: %11
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%2 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %7
%3 = alloc_stack $Optional<Int> // users: %5, %7, %8
%4 = load %0 : $*Optional<Int> // user: %5
store %4 to %3#1 : $*Optional<Int> // id: %5
%6 = struct $_OptionalNilComparisonType () // user: %7
%7 = apply %2<Int>(%3#1, %6) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %10
dealloc_stack %3#0 : $*@local_storage Optional<Int> // id: %8
%9 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %11
%10 = struct_extract %7 : $Bool, #Bool.value // user: %11
%11 = apply %9(%10, %1) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = tuple () // user: %14
return %13 : $() // id: %14
}
// specialization <(index : Swift.Int, element : Swift.Int)> of Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
sil shared [transparent] specialization <(index : Swift.Int, element : Swift.Int)> of Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin (@out Optional<(index: Int, element: Int)>, @in (index: Int, element: Int), @thin Optional<(index: Int, element: Int)>.Type) -> () {
bb0(%0 : $*Optional<(index: Int, element: Int)>, %1 : $*(index: Int, element: Int), %2 : $@thin Optional<(index: Int, element: Int)>.Type):
%3 = load %1 : $*(index: Int, element: Int) // user: %4
%4 = enum $Optional<(index: Int, element: Int)>, #Optional.Some!enumelt.1, %3 : $(index: Int, element: Int) // user: %5
store %4 to %0 : $*Optional<(index: Int, element: Int)> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
sil shared [transparent] specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin (@inout Optional<_ContiguousArrayStorage<Int>>) -> Builtin.Int1 {
bb0(%0 : $*Optional<_ContiguousArrayStorage<Int>>):
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%1 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %7
%2 = alloc_stack $Optional<_ContiguousArrayStorage<Int>> // users: %4, %7, %9
%3 = load %0 : $*Optional<_ContiguousArrayStorage<Int>> // users: %4, %6
store %3 to %2#1 : $*Optional<_ContiguousArrayStorage<Int>> // id: %4
%5 = struct $_OptionalNilComparisonType () // user: %7
retain_value %3 : $Optional<_ContiguousArrayStorage<Int>> // id: %6
%7 = apply %1<_ContiguousArrayStorage<Int>>(%2#1, %5) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %8
%8 = struct_extract %7 : $Bool, #Bool.value // user: %10
dealloc_stack %2#0 : $*@local_storage Optional<_ContiguousArrayStorage<Int>> // id: %9
return %8 : $Builtin.Int1 // id: %10
}
// specialization <Swift.Int> of Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
sil shared [transparent] specialization <Swift.Int> of Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin (@inout Optional<Int>) -> Builtin.Int1 {
bb0(%0 : $*Optional<Int>):
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%1 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %6
%2 = alloc_stack $Optional<Int> // users: %4, %6, %8
%3 = load %0 : $*Optional<Int> // user: %4
store %3 to %2#1 : $*Optional<Int> // id: %4
%5 = struct $_OptionalNilComparisonType () // user: %6
%6 = apply %1<Int>(%2#1, %5) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %7
%7 = struct_extract %6 : $Bool, #Bool.value // user: %9
dealloc_stack %2#0 : $*@local_storage Optional<Int> // id: %8
return %7 : $Builtin.Int1 // id: %9
}
// specialization <(index : Swift.Int, element : Swift.Int)> of Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
sil shared [transparent] specialization <(index : Swift.Int, element : Swift.Int)> of Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin (@inout Optional<(index: Int, element: Int)>) -> Builtin.Int1 {
bb0(%0 : $*Optional<(index: Int, element: Int)>):
// function_ref Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%1 = function_ref Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %6
%2 = alloc_stack $Optional<(index: Int, element: Int)> // users: %4, %6, %8
%3 = load %0 : $*Optional<(index: Int, element: Int)> // user: %4
store %3 to %2#1 : $*Optional<(index: Int, element: Int)> // id: %4
%5 = struct $_OptionalNilComparisonType () // user: %6
%6 = apply %1<(index: Int, element: Int)>(%2#1, %5) : $@thin <τ_0_0> (@in Optional<τ_0_0>, _OptionalNilComparisonType) -> Bool // user: %7
%7 = struct_extract %6 : $Bool, #Bool.value // user: %9
dealloc_stack %2#0 : $*@local_storage Optional<(index: Int, element: Int)> // id: %8
return %7 : $Builtin.Int1 // id: %9
}
// specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
sil shared specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin (@in Optional<_ContiguousArrayStorage<Int>>, _OptionalNilComparisonType) -> Bool {
bb0(%0 : $*Optional<_ContiguousArrayStorage<Int>>, %1 : $_OptionalNilComparisonType):
%2 = load %0 : $*Optional<_ContiguousArrayStorage<Int>> // users: %3, %5
%3 = enum_is_tag $Builtin.Int1, %2 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %4
%4 = struct $Bool (%3 : $Builtin.Int1) // user: %6
release_value %2 : $Optional<_ContiguousArrayStorage<Int>> // id: %5
return %4 : $Bool // id: %6
}
// specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
sil shared [transparent] specialization <Swift._ContiguousArrayStorage<Swift.Int>> of Swift._getOptionalValue <A>(A?) -> A : $@thin (@out _ContiguousArrayStorage<Int>, @in Optional<_ContiguousArrayStorage<Int>>) -> () {
bb0(%0 : $*_ContiguousArrayStorage<Int>, %1 : $*Optional<_ContiguousArrayStorage<Int>>):
%2 = load %1 : $*Optional<_ContiguousArrayStorage<Int>> // users: %3, %4
switch_enum %2 : $Optional<_ContiguousArrayStorage<Int>>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %3
bb1: // Preds: bb0
%4 = unchecked_enum_data %2 : $Optional<_ContiguousArrayStorage<Int>>, #Optional.Some!enumelt.1 // user: %5
store %4 to %0 : $*_ContiguousArrayStorage<Int> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
bb2: // Preds: bb0
%8 = integer_literal $Builtin.Int1, -1 // user: %9
cond_fail %8 : $Builtin.Int1 // id: %9
unreachable // id: %10
}
// specialization <Swift.Int> of Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
sil shared [transparent] specialization <Swift.Int> of Swift._getOptionalValue <A>(A?) -> A : $@thin (@out Int, @in Optional<Int>) -> () {
bb0(%0 : $*Int, %1 : $*Optional<Int>):
%2 = load %1 : $*Optional<Int> // users: %3, %4
switch_enum %2 : $Optional<Int>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %3
bb1: // Preds: bb0
%4 = unchecked_enum_data %2 : $Optional<Int>, #Optional.Some!enumelt.1 // user: %5
store %4 to %0 : $*Int // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
bb2: // Preds: bb0
%8 = integer_literal $Builtin.Int1, -1 // user: %9
cond_fail %8 : $Builtin.Int1 // id: %9
unreachable // id: %10
}
// specialization <(index : Swift.Int, element : Swift.Int)> of Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
sil shared [transparent] specialization <(index : Swift.Int, element : Swift.Int)> of Swift._getOptionalValue <A>(A?) -> A : $@thin (@out (index: Int, element: Int), @in Optional<(index: Int, element: Int)>) -> () {
bb0(%0 : $*(index: Int, element: Int), %1 : $*Optional<(index: Int, element: Int)>):
%2 = load %1 : $*Optional<(index: Int, element: Int)> // users: %3, %4
switch_enum %2 : $Optional<(index: Int, element: Int)>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %3
bb1: // Preds: bb0
%4 = unchecked_enum_data %2 : $Optional<(index: Int, element: Int)>, #Optional.Some!enumelt.1 // user: %5
store %4 to %0 : $*(index: Int, element: Int) // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
bb2: // Preds: bb0
%8 = integer_literal $Builtin.Int1, -1 // user: %9
cond_fail %8 : $Builtin.Int1 // id: %9
unreachable // id: %10
}
// specialization <Swift.Int> of Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.Int> of Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin (@out Optional<Int>, @thin Optional<Int>.Type) -> () {
bb0(%0 : $*Optional<Int>, %1 : $@thin Optional<Int>.Type):
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%2 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %5
%3 = metatype $@thin Optional<Int>.Type // user: %5
%4 = alloc_stack $Optional<Int> // users: %5, %6, %7
%5 = apply [transparent] %2<Int>(%4#1, %3) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
%6 = load %4#1 : $*Optional<Int> // user: %8
dealloc_stack %4#0 : $*@local_storage Optional<Int> // id: %7
store %6 to %0 : $*Optional<Int> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift.Int> of Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.Int> of Swift.Optional.None <A>(A?.Type) -> A? : $@thin (@out Optional<Int>, @thin Optional<Int>.Type) -> () {
bb0(%0 : $*Optional<Int>, %1 : $@thin Optional<Int>.Type):
%2 = enum $Optional<Int>, #Optional.None!enumelt // user: %3
store %2 to %0 : $*Optional<Int> // id: %3
%4 = tuple () // user: %5
return %4 : $() // id: %5
}
// specialization <(index : Swift.Int, element : Swift.Int)> of Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
sil shared [transparent] specialization <(index : Swift.Int, element : Swift.Int)> of Swift.Optional.None <A>(A?.Type) -> A? : $@thin (@out Optional<(index: Int, element: Int)>, @thin Optional<(index: Int, element: Int)>.Type) -> () {
bb0(%0 : $*Optional<(index: Int, element: Int)>, %1 : $@thin Optional<(index: Int, element: Int)>.Type):
%2 = enum $Optional<(index: Int, element: Int)>, #Optional.None!enumelt // user: %3
store %2 to %0 : $*Optional<(index: Int, element: Int)> // id: %3
%4 = tuple () // user: %5
return %4 : $() // id: %5
}
// protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafePointer : Swift._PointerType
sil public_external protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafePointer : Swift._PointerType : $@cc(witness_method) @thin <T> (@inout UnsafePointer<T>) -> Builtin.RawPointer {
bb0(%0 : $*UnsafePointer<T>):
%1 = load %0 : $*UnsafePointer<T> // user: %3
// function_ref Swift.UnsafePointer.value.getter : Builtin.RawPointer
%2 = function_ref Swift.UnsafePointer.value.getter : Builtin.RawPointer : $@cc(method) @thin <τ_0_0> (UnsafePointer<τ_0_0>) -> Builtin.RawPointer // user: %3
%3 = apply %2<T>(%1) : $@cc(method) @thin <τ_0_0> (UnsafePointer<τ_0_0>) -> Builtin.RawPointer // user: %4
return %3 : $Builtin.RawPointer // id: %4
}
// protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafePointer : Swift._PointerType
sil public_external protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafePointer : Swift._PointerType : $@cc(witness_method) @thin <T> (@out UnsafePointer<T>, Builtin.RawPointer, @thick UnsafePointer<T>.Type) -> () {
bb0(%0 : $*UnsafePointer<T>, %1 : $Builtin.RawPointer, %2 : $@thick UnsafePointer<T>.Type):
%3 = metatype $@thin UnsafePointer<T>.Type // user: %5
// function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A>
%4 = function_ref Swift.UnsafePointer.init <A>(Swift.UnsafePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %5
%5 = apply %4<T>(%1, %3) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafePointer<τ_0_0>.Type) -> UnsafePointer<τ_0_0> // user: %6
store %5 to %0 : $*UnsafePointer<T> // id: %6
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafeMutablePointer : Swift._PointerType
sil public_external protocol witness for Swift._PointerType.value.getter : Builtin.RawPointer in conformance Swift.UnsafeMutablePointer : Swift._PointerType : $@cc(witness_method) @thin <T> (@inout UnsafeMutablePointer<T>) -> Builtin.RawPointer {
bb0(%0 : $*UnsafeMutablePointer<T>):
%1 = load %0 : $*UnsafeMutablePointer<T> // user: %3
// function_ref Swift.UnsafeMutablePointer.value.getter : Builtin.RawPointer
%2 = function_ref Swift.UnsafeMutablePointer.value.getter : Builtin.RawPointer : $@cc(method) @thin <τ_0_0> (UnsafeMutablePointer<τ_0_0>) -> Builtin.RawPointer // user: %3
%3 = apply %2<T>(%1) : $@cc(method) @thin <τ_0_0> (UnsafeMutablePointer<τ_0_0>) -> Builtin.RawPointer // user: %4
return %3 : $Builtin.RawPointer // id: %4
}
// protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafeMutablePointer : Swift._PointerType
sil public_external protocol witness for Swift._PointerType.init <A : Swift._PointerType>(Swift._PointerType.Self.Type)(Builtin.RawPointer) -> Swift._PointerType.Self in conformance Swift.UnsafeMutablePointer : Swift._PointerType : $@cc(witness_method) @thin <T> (@out UnsafeMutablePointer<T>, Builtin.RawPointer, @thick UnsafeMutablePointer<T>.Type) -> () {
bb0(%0 : $*UnsafeMutablePointer<T>, %1 : $Builtin.RawPointer, %2 : $@thick UnsafeMutablePointer<T>.Type):
%3 = metatype $@thin UnsafeMutablePointer<T>.Type // user: %5
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%4 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %5
%5 = apply %4<T>(%1, %3) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %6
store %5 to %0 : $*UnsafeMutablePointer<T> // id: %6
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// Swift.UnsafeMutablePointer.value.getter : Builtin.RawPointer
sil public_external [transparent] Swift.UnsafeMutablePointer.value.getter : Builtin.RawPointer : $@cc(method) @thin <T> (UnsafeMutablePointer<T>) -> Builtin.RawPointer {
bb0(%0 : $UnsafeMutablePointer<T>):
%1 = struct_extract %0 : $UnsafeMutablePointer<T>, #UnsafeMutablePointer.value // user: %2
return %1 : $Builtin.RawPointer // id: %2
}
// protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.UnsafeBufferPointer : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.UnsafeBufferPointer : Swift.SequenceType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>.Generator, @inout UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*UnsafeBufferPointerGenerator<T>, %1 : $*UnsafeBufferPointer<T>):
%2 = load %1 : $*UnsafeBufferPointer<T> // user: %4
// function_ref Swift.UnsafeBufferPointer.generate <A>(Swift.UnsafeBufferPointer<A>)() -> Swift.UnsafeBufferPointerGenerator<A>
%3 = function_ref Swift.UnsafeBufferPointer.generate <A>(Swift.UnsafeBufferPointer<A>)() -> Swift.UnsafeBufferPointerGenerator<A> : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> UnsafeBufferPointerGenerator<τ_0_0> // user: %4
%4 = apply %3<T>(%2) : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> UnsafeBufferPointerGenerator<τ_0_0> // user: %5
store %4 to %0 : $*UnsafeBufferPointerGenerator<T> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._UnderestimateCount, ())) -> Swift.Int in conformance Swift.UnsafeBufferPointer : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._UnderestimateCount, ())) -> Swift.Int in conformance Swift.UnsafeBufferPointer : Swift.SequenceType : $@cc(witness_method) @thin <T> (@in UnsafeBufferPointer<T>, _UnderestimateCount, @thick UnsafeBufferPointer<T>.Type) -> Int {
bb0(%0 : $*UnsafeBufferPointer<T>, %1 : $_UnderestimateCount, %2 : $@thick UnsafeBufferPointer<T>.Type):
%3 = load %0 : $*UnsafeBufferPointer<T> // user: %5
%4 = alloc_stack $UnsafeBufferPointer<T> // users: %5, %7, %8
store %3 to %4#1 : $*UnsafeBufferPointer<T> // id: %5
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int
%6 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0, _UnderestimateCount) -> Int // user: %7
%7 = apply %6<UnsafeBufferPointer<T>, Int, Int, Int, Int, T>(%4#1, %1) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0, _UnderestimateCount) -> Int // user: %9
dealloc_stack %4#0 : $*@local_storage UnsafeBufferPointer<T> // id: %8
return %7 : $Int // id: %9
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)<C>(Swift.SequenceType.Self, (Swift._PreprocessingPass, (Swift.SequenceType.Self) -> C)) -> Swift.Optional<C> in conformance Swift.UnsafeBufferPointer : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)<C>(Swift.SequenceType.Self, (Swift._PreprocessingPass, (Swift.SequenceType.Self) -> C)) -> C? in conformance Swift.UnsafeBufferPointer : Swift.SequenceType : $@cc(witness_method) @thin <T><R> (@out Optional<R>, @in UnsafeBufferPointer<T>, _PreprocessingPass, @owned @callee_owned (@out R, @in UnsafeBufferPointer<T>) -> (), @thick UnsafeBufferPointer<T>.Type) -> () {
bb0(%0 : $*Optional<R>, %1 : $*UnsafeBufferPointer<T>, %2 : $_PreprocessingPass, %3 : $@callee_owned (@out R, @in UnsafeBufferPointer<T>) -> (), %4 : $@thick UnsafeBufferPointer<T>.Type):
%5 = load %1 : $*UnsafeBufferPointer<T> // user: %9
// function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0)
%6 = function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, UnsafeBufferPointer<τ_0_0>, @owned @callee_owned (@out τ_1_0, @in UnsafeBufferPointer<τ_0_0>) -> ()) -> () // user: %7
%7 = partial_apply %6<T, R>(%3) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, UnsafeBufferPointer<τ_0_0>, @owned @callee_owned (@out τ_1_0, @in UnsafeBufferPointer<τ_0_0>) -> ()) -> () // user: %11
%8 = alloc_stack $UnsafeBufferPointer<T> // users: %9, %13, %14
store %5 to %8#1 : $*UnsafeBufferPointer<T> // id: %9
// function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0)
%10 = function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @in UnsafeBufferPointer<τ_0_0>, @owned @callee_owned (@out τ_1_0, UnsafeBufferPointer<τ_0_0>) -> ()) -> () // user: %11
%11 = partial_apply %10<T, R>(%7) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @in UnsafeBufferPointer<τ_0_0>, @owned @callee_owned (@out τ_1_0, UnsafeBufferPointer<τ_0_0>) -> ()) -> () // user: %13
// function_ref Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> Swift.Optional<B>
%12 = function_ref Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> B? : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_1>, @in τ_0_0, _PreprocessingPass, @owned @callee_owned (@out τ_0_1, @in τ_0_0) -> ()) -> () // user: %13
%13 = apply %12<UnsafeBufferPointer<T>, R, Int, Int, Int, Int, T>(%0, %8#1, %2, %11) : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_1>, @in τ_0_0, _PreprocessingPass, @owned @callee_owned (@out τ_0_1, @in τ_0_0) -> ()) -> () // user: %15
dealloc_stack %8#0 : $*@local_storage UnsafeBufferPointer<T> // id: %14
return %13 : $() // id: %15
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.UnsafeBufferPointer : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.UnsafeBufferPointer : Swift.SequenceType : $@cc(witness_method) @thin <T> (@in UnsafeBufferPointer<T>, _CopyToNativeArrayBuffer, @thick UnsafeBufferPointer<T>.Type) -> @owned _ContiguousArrayBuffer<UnsafeBufferPointer<T>.Generator.Element> {
bb0(%0 : $*UnsafeBufferPointer<T>, %1 : $_CopyToNativeArrayBuffer, %2 : $@thick UnsafeBufferPointer<T>.Type):
%3 = load %0 : $*UnsafeBufferPointer<T> // user: %5
%4 = alloc_stack $UnsafeBufferPointer<T> // users: %5, %7, %8
store %3 to %4#1 : $*UnsafeBufferPointer<T> // id: %5
// function_ref Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element>
%6 = function_ref Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %7
%7 = apply %6<UnsafeBufferPointer<T>, UnsafeBufferPointerGenerator<T>, T, Int, Int, Int, Int>(%4#1, %1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %9
dealloc_stack %4#0 : $*@local_storage UnsafeBufferPointer<T> // id: %8
return %7 : $_ContiguousArrayBuffer<T> // id: %9
}
// Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element>
sil public_external Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, C.Generator.Element == C._Element> (@in C, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<C.Generator.Element> {
bb0(%0 : $*C, %1 : $_CopyToNativeArrayBuffer):
// function_ref Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element>
%2 = function_ref Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %5
%3 = alloc_stack $C // users: %4, %5, %6
copy_addr %0 to [initialization] %3#1 : $*C // id: %4
%5 = apply %2<C, C.Generator, C._Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex>(%3#1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %8
dealloc_stack %3#0 : $*@local_storage C // id: %6
destroy_addr %0 : $*C // id: %7
return %5 : $_ContiguousArrayBuffer<C._Element> // id: %8
}
// Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element>
sil public_external Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, C.Generator.Element == C._Element> (@in C) -> @owned _ContiguousArrayBuffer<C.Generator.Element> {
bb0(%0 : $*C):
%1 = alloc_stack $UnsafeMutablePointer<C._Element> // users: %34, %49, %70
%2 = alloc_stack $C.Index // users: %36, %48, %53, %59, %74
// function_ref Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance
%3 = function_ref Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0) -> () // user: %7
%4 = alloc_stack $C // users: %5, %7, %15
copy_addr %0 to [initialization] %4#1 : $*C // id: %5
%6 = alloc_stack $C.Index.Distance // users: %7, %9, %13, %14
%7 = apply %3<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%6#1, %4#1) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0) -> ()
%8 = witness_method $C.Index.Distance, #_SignedIntegerType.toIntMax!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@inout τ_0_0) -> Int64 // user: %9
%9 = apply %8<C.Index.Distance, C.Index.Distance.IntegerLiteralType>(%6#1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@inout τ_0_0) -> Int64 // user: %10
%10 = struct_extract %9 : $Int64, #Int64.value // user: %12
%11 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %12
%12 = apply %11(%10) : $@thin (Builtin.Int64) -> Builtin.Word // users: %18, %26, %40, %44, %81
destroy_addr %6#1 : $*C.Index.Distance // id: %13
dealloc_stack %6#0 : $*@local_storage C.Index.Distance // id: %14
dealloc_stack %4#0 : $*@local_storage C // id: %15
%16 = integer_literal $Builtin.Word, 0 // users: %18, %27, %40, %44, %61
%17 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %18, %44, %81
%18 = apply %17(%12, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
cond_br %18, bb1, bb2 // id: %19
bb1: // Preds: bb0
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A>
%20 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %22
%21 = metatype $@thin _ContiguousArrayBuffer<C._Element>.Type // user: %22
%22 = apply %20<C._Element>(%21) : $@thin <τ_0_0> (@thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %23
br bb3(%22 : $_ContiguousArrayBuffer<C._Element>) // id: %23
bb2: // Preds: bb0
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A>
%24 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (Int, Int, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %28
%25 = metatype $@thin _ContiguousArrayBuffer<C._Element>.Type // user: %28
%26 = struct $Int (%12 : $Builtin.Word) // user: %28
%27 = struct $Int (%16 : $Builtin.Word) // user: %28
%28 = apply %24<C._Element>(%26, %27, %25) : $@thin <τ_0_0> (Int, Int, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // users: %29, %33, %60
%29 = struct_extract %28 : $_ContiguousArrayBuffer<C._Element>, #_ContiguousArrayBuffer._base // user: %30
%30 = struct_extract %29 : $HeapBuffer<_ArrayBody, C._Element>, #HeapBuffer.storage // user: %32
// function_ref Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A>
%31 = function_ref Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %33
retain_value %30 : $Optional<HeapBufferStorage<_ArrayBody, C._Element>> // id: %32
%33 = apply %31<C._Element>(%28) : $@cc(method) @thin <τ_0_0> (@owned _ContiguousArrayBuffer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0> // user: %34
store %33 to %1#1 : $*UnsafeMutablePointer<C._Element> // id: %34
%35 = witness_method $C, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %36
%36 = apply %35<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%2#1, %0) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%37 = integer_literal $Builtin.Int1, 0 // user: %65
%38 = integer_literal $Builtin.Int1, -1 // user: %42
%39 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %40
%40 = apply %39(%16, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %42
%41 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %42
%42 = apply %41(%40, %38) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %43
cond_fail %42 : $Builtin.Int1 // id: %43
%44 = apply %17(%16, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %45
cond_br %44, bb4, bb5 // id: %45
bb3(%46 : $_ContiguousArrayBuffer<C._Element>): // Preds: bb1 bb4
destroy_addr %0 : $*C // id: %47
dealloc_stack %2#0 : $*@local_storage C.Index // id: %48
dealloc_stack %1#0 : $*@local_storage UnsafeMutablePointer<C._Element> // id: %49
return %46 : $_ContiguousArrayBuffer<C._Element> // id: %50
bb4: // Preds: bb2 bb6
// function_ref Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> ()
%51 = function_ref Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> () : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0.Index, @in τ_0_0) -> () // user: %56
%52 = alloc_stack $C.Index // users: %53, %56, %58
copy_addr %2#1 to [initialization] %52#1 : $*C.Index // id: %53
%54 = alloc_stack $C // users: %55, %56, %57
copy_addr %0 to [initialization] %54#1 : $*C // id: %55
%56 = apply %51<C, C.Generator, C._Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%52#1, %54#1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0.Index, @in τ_0_0) -> ()
dealloc_stack %54#0 : $*@local_storage C // id: %57
dealloc_stack %52#0 : $*@local_storage C.Index // id: %58
destroy_addr %2#1 : $*C.Index // id: %59
br bb3(%28 : $_ContiguousArrayBuffer<C._Element>) // id: %60
bb5: // Preds: bb2
br bb6(%16 : $Builtin.Word) // id: %61
bb6(%62 : $Builtin.Word): // Preds: bb5 bb6
%63 = integer_literal $Builtin.Word, 1 // user: %65
%64 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = apply %64(%62, %63, %37) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %66
%66 = tuple_extract %65 : $(Builtin.Word, Builtin.Int1), 0 // users: %81, %82
// function_ref Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> ()
%67 = function_ref Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> () : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %77
// function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
%68 = function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> () // users: %70, %74
%69 = alloc_stack $UnsafeMutablePointer<C._Element> // users: %70, %71, %80
%70 = apply [transparent] %68<UnsafeMutablePointer<C._Element>>(%69#1, %1#1) : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> ()
%71 = load %69#1 : $*UnsafeMutablePointer<C._Element> // user: %77
%72 = alloc_stack $C._Element // users: %76, %77, %79
%73 = alloc_stack $C.Index // users: %74, %76, %78
%74 = apply [transparent] %68<C.Index>(%73#1, %2#1) : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> ()
%75 = witness_method $C, #CollectionType.subscript!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> () // user: %76
%76 = apply %75<C, C.Generator, C._Element, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%72#1, %73#1, %0) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> ()
%77 = apply %67<C._Element>(%72#1, %71) : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
dealloc_stack %73#0 : $*@local_storage C.Index // id: %78
dealloc_stack %72#0 : $*@local_storage C._Element // id: %79
dealloc_stack %69#0 : $*@local_storage UnsafeMutablePointer<C._Element> // id: %80
%81 = apply %17(%66, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %82
cond_br %81, bb4, bb6(%66 : $Builtin.Word) // id: %82
}
// Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance
sil public_external Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance : $@thin <T where T : _CollectionType, T.Index : ForwardIndexType, T.Index.Distance : _SignedIntegerType, T.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T.Index.Distance, @in T) -> () {
bb0(%0 : $*T.Index.Distance, %1 : $*T):
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
%2 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %6
%3 = alloc_stack $T // users: %4, %6, %7
copy_addr %1 to [initialization] %3#1 : $*T // id: %4
%5 = struct $_CountElements () // user: %6
%6 = apply %2<T, T.Index, T.Index.Distance, T.Index.Distance.IntegerLiteralType, T.Index._DisabledRangeIndex, T._Element>(%0, %3#1, %5) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> ()
dealloc_stack %3#0 : $*@local_storage T // id: %7
destroy_addr %1 : $*T // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A>
sil public_external Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A> : $@thin <T> (@thin _ContiguousArrayBuffer<T>.Type) -> @owned _ContiguousArrayBuffer<T> {
bb0(%0 : $@thin _ContiguousArrayBuffer<T>.Type):
// function_ref Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B>
%1 = function_ref Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B> : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> @owned HeapBuffer<τ_0_0, τ_0_1> // user: %3
%2 = metatype $@thin HeapBuffer<_ArrayBody, T>.Type // user: %3
%3 = apply %1<_ArrayBody, T>(%2) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> @owned HeapBuffer<τ_0_0, τ_0_1> // user: %4
%4 = struct $_ContiguousArrayBuffer<T> (%3 : $HeapBuffer<_ArrayBody, T>) // user: %5
return %4 : $_ContiguousArrayBuffer<T> // id: %5
}
// Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A>
sil public_external Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A> : $@thin <T> (Int, Int, @thin _ContiguousArrayBuffer<T>.Type) -> @owned _ContiguousArrayBuffer<T> {
bb0(%0 : $Int, %1 : $Int, %2 : $@thin _ContiguousArrayBuffer<T>.Type):
// function_ref Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B>
%3 = function_ref Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B> : $@thin <τ_0_0, τ_0_1> (@thick AnyObject.Type, @in τ_0_0, Int, @thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> @owned HeapBuffer<τ_0_0, τ_0_1> // user: %21
%4 = metatype $@thin HeapBuffer<_ArrayBody, T>.Type // user: %21
%5 = metatype $@thick _ContiguousArrayStorage<T>.Type // user: %6
%6 = upcast %5 : $@thick _ContiguousArrayStorage<T>.Type to $@thick AnyObject.Type // user: %21
%7 = alloc_stack $_ArrayBody // users: %12, %21, %22
%8 = integer_literal $Builtin.Word, 0 // users: %9, %10, %56
%9 = struct $Int (%8 : $Builtin.Word) // user: %11
%10 = struct $UInt (%8 : $Builtin.Word) // user: %11
%11 = struct $_ArrayBody (%9 : $Int, %10 : $UInt) // user: %12
store %11 to %7#1 : $*_ArrayBody // id: %12
%13 = struct_extract %0 : $Int, #Int.value // users: %16, %18
%14 = struct_extract %1 : $Int, #Int.value // users: %16, %17
%15 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
%16 = apply %15(%14, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
cond_br %16, bb1, bb2(%14 : $Builtin.Word) // id: %17
bb1: // Preds: bb0
br bb2(%13 : $Builtin.Word) // id: %18
bb2(%19 : $Builtin.Word): // Preds: bb0 bb1
%20 = struct $Int (%19 : $Builtin.Word) // user: %21
%21 = apply %3<_ArrayBody, T>(%6, %7#1, %20, %4) : $@thin <τ_0_0, τ_0_1> (@thick AnyObject.Type, @in τ_0_0, Int, @thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> @owned HeapBuffer<τ_0_0, τ_0_1> // users: %38, %40, %66, %68
dealloc_stack %7#0 : $*@local_storage _ArrayBody // id: %22
%23 = integer_literal $Builtin.Int1, 0 // user: %31
// function_ref Swift._canBeClass <A>(A.Type) -> Swift.Int8
%24 = function_ref Swift._canBeClass <A>(A.Type) -> Swift.Int8 : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int8 // user: %26
%25 = metatype $@thick T.Type // users: %26, %33
%26 = apply [transparent] %24<T>(%25) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int8 // user: %29
%27 = integer_literal $Builtin.Int8, 0 // user: %30
%28 = builtin_function_ref "cmp_ne_Int8" : $@thin (Builtin.Int8, Builtin.Int8) -> Builtin.Int1 // user: %30
%29 = struct_extract %26 : $Int8, #Int8.value // user: %30
%30 = apply %28(%29, %27) : $@thin (Builtin.Int8, Builtin.Int8) -> Builtin.Int1 // user: %31
cond_br %30, bb3, bb4(%23 : $Builtin.Int1) // id: %31
bb3: // Preds: bb2
// function_ref Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool
%32 = function_ref Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %33
%33 = apply %32<T>(%25) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %34
%34 = struct_extract %33 : $Bool, #Bool.value // user: %35
br bb4(%34 : $Builtin.Int1) // id: %35
bb4(%36 : $Builtin.Int1): // Preds: bb2 bb3
// function_ref Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
%37 = function_ref Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Int // user: %40
%38 = struct_extract %21 : $HeapBuffer<_ArrayBody, T>, #HeapBuffer.storage // users: %39, %65
retain_value %38 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %39
%40 = apply %37<_ArrayBody, T>(%21) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Int // user: %42
%41 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %43
%42 = struct_extract %40 : $Int, #Int.value // user: %43
%43 = apply %41(%42) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %45
%44 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %45
%45 = apply %44(%43) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %46, %47
%46 = tuple_extract %45 : $(Builtin.Int64, Builtin.Int1), 0 // user: %50
%47 = tuple_extract %45 : $(Builtin.Int64, Builtin.Int1), 1 // user: %48
cond_fail %47 : $Builtin.Int1 // id: %48
%49 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %50
%50 = apply %49(%46) : $@thin (Builtin.Int64) -> Builtin.Word // user: %53
%51 = integer_literal $Builtin.Word, 1 // users: %53, %55
%52 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %53
%53 = apply %52(%50, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %59
cond_br %36, bb5, bb6 // id: %54
bb5: // Preds: bb4
br bb7(%51 : $Builtin.Word) // id: %55
bb6: // Preds: bb4
br bb7(%8 : $Builtin.Word) // id: %56
bb7(%57 : $Builtin.Word): // Preds: bb5 bb6
%58 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %59
%59 = apply %58(%53, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %60
%60 = struct $UInt (%59 : $Builtin.Word) // user: %61
%61 = struct $_ArrayBody (%0 : $Int, %60 : $UInt) // user: %64
// function_ref Swift.HeapBuffer.value.setter : A
%62 = function_ref Swift.HeapBuffer.value.setter : A : $@cc(method) @thin <τ_0_0, τ_0_1> (@in τ_0_0, @owned HeapBuffer<τ_0_0, τ_0_1>) -> () // user: %66
%63 = alloc_stack $_ArrayBody // users: %64, %66, %67
store %61 to %63#1 : $*_ArrayBody // id: %64
retain_value %38 : $Optional<HeapBufferStorage<_ArrayBody, T>> // id: %65
%66 = apply %62<_ArrayBody, T>(%63#1, %21) : $@cc(method) @thin <τ_0_0, τ_0_1> (@in τ_0_0, @owned HeapBuffer<τ_0_0, τ_0_1>) -> ()
dealloc_stack %63#0 : $*@local_storage _ArrayBody // id: %67
%68 = struct $_ContiguousArrayBuffer<T> (%21 : $HeapBuffer<_ArrayBody, T>) // user: %69
return %68 : $_ContiguousArrayBuffer<T> // id: %69
}
// Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> ()
sil public_external Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> () : $@thin <C where C : CollectionType, C.Generator : GeneratorType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in C.Index, @in C) -> () {
bb0(%0 : $*C.Index, %1 : $*C):
%2 = alloc_stack $C.Index // users: %4, %6, %12
%3 = alloc_stack $C // users: %5, %7, %11
copy_addr %0 to [initialization] %2#1 : $*C.Index // id: %4
copy_addr %1 to [initialization] %3#1 : $*C // id: %5
destroy_addr %2#1 : $*C.Index // id: %6
destroy_addr %3#1 : $*C // id: %7
destroy_addr %1 : $*C // id: %8
destroy_addr %0 : $*C.Index // id: %9
%10 = tuple () // user: %13
dealloc_stack %3#0 : $*@local_storage C // id: %11
dealloc_stack %2#0 : $*@local_storage C.Index // id: %12
return %10 : $() // id: %13
}
// Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> ()
sil public_external Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> () : $@cc(method) @thin <T> (@in T, UnsafeMutablePointer<T>) -> () {
bb0(%0 : $*T, %1 : $UnsafeMutablePointer<T>):
%2 = alloc_stack $T // users: %3, %6, %7
copy_addr %0 to [initialization] %2#1 : $*T // id: %3
%4 = struct_extract %1 : $UnsafeMutablePointer<T>, #UnsafeMutablePointer.value // user: %5
%5 = pointer_to_address %4 : $Builtin.RawPointer to $*T // user: %6
copy_addr [take] %2#1 to [initialization] %5 : $*T // id: %6
dealloc_stack %2#0 : $*@local_storage T // id: %7
destroy_addr %0 : $*T // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
sil public_external Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <T where T : _CollectionType, T.Index : ForwardIndexType, T.Index.Distance : _SignedIntegerType, T.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T.Index.Distance, @in T, _CountElements) -> () {
bb0(%0 : $*T.Index.Distance, %1 : $*T, %2 : $_CountElements):
// function_ref Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance
%3 = function_ref Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Distance, @in τ_0_0, @in τ_0_0) -> () // user: %10
%4 = alloc_stack $T.Index // users: %6, %10, %12
%5 = witness_method $T, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %6
%6 = apply %5<T, T.Index, T.Index.Distance, T.Index.Distance.IntegerLiteralType, T.Index._DisabledRangeIndex, T._Element>(%4#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%7 = alloc_stack $T.Index // users: %9, %10, %11
%8 = witness_method $T, #_CollectionType.endIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %9
%9 = apply %8<T, T.Index, T.Index.Distance, T.Index.Distance.IntegerLiteralType, T.Index._DisabledRangeIndex, T._Element>(%7#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%10 = apply %3<T.Index, T.Index.Distance, T.Index.Distance.IntegerLiteralType, T.Index._DisabledRangeIndex>(%0, %4#1, %7#1) : $@thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Distance, @in τ_0_0, @in τ_0_0) -> ()
dealloc_stack %7#0 : $*@local_storage T.Index // id: %11
dealloc_stack %4#0 : $*@local_storage T.Index // id: %12
destroy_addr %1 : $*T // id: %13
%14 = tuple () // user: %15
return %14 : $() // id: %15
}
// Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B>
sil public_external Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B> : $@thin <Value, Element> (@thin HeapBuffer<Value, Element>.Type) -> @owned HeapBuffer<Value, Element> {
bb0(%0 : $@thin HeapBuffer<Value, Element>.Type):
// function_ref Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
%1 = function_ref Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %4
%2 = metatype $@thin Optional<HeapBufferStorage<Value, Element>>.Type // users: %4, %9
%3 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %4, %5, %6
%4 = apply [transparent] %1<HeapBufferStorage<Value, Element>>(%3#1, %2) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
%5 = load %3#1 : $*Optional<HeapBufferStorage<Value, Element>> // user: %11
dealloc_stack %3#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %6
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%7 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %9
%8 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %9, %10, %12
%9 = apply [transparent] %7<HeapBufferStorage<Value, Element>>(%8#1, %2) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
%10 = load %8#1 : $*Optional<HeapBufferStorage<Value, Element>> // user: %13
release_value %5 : $Optional<HeapBufferStorage<Value, Element>> // id: %11
dealloc_stack %8#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %12
%13 = struct $HeapBuffer<Value, Element> (%10 : $Optional<HeapBufferStorage<Value, Element>>) // user: %14
return %13 : $HeapBuffer<Value, Element> // id: %14
}
// Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B>
sil public_external Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B> : $@thin <Value, Element> (@thick AnyObject.Type, @in Value, Int, @thin HeapBuffer<Value, Element>.Type) -> @owned HeapBuffer<Value, Element> {
bb0(%0 : $@thick AnyObject.Type, %1 : $*Value, %2 : $Int, %3 : $@thin HeapBuffer<Value, Element>.Type):
// function_ref Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
%4 = function_ref Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %7
%5 = metatype $@thin Optional<HeapBufferStorage<Value, Element>>.Type // user: %7
%6 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %7, %8, %9
%7 = apply [transparent] %4<HeapBufferStorage<Value, Element>>(%6#1, %5) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
%8 = load %6#1 : $*Optional<HeapBufferStorage<Value, Element>> // user: %47
dealloc_stack %6#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %9
// function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%10 = function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %12
%11 = metatype $@thin HeapBuffer<Value, Element>.Type // users: %12, %32
%12 = apply %10<Value, Element>(%11) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %25
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%13 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %15
%14 = metatype $@thick Element.Type // user: %15
%15 = apply [transparent] %13<Element>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %18
%16 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %20
%17 = struct_extract %2 : $Int, #Int.value // user: %20
%18 = struct_extract %15 : $Int, #Int.value // user: %20
%19 = integer_literal $Builtin.Int1, -1 // users: %20, %26
%20 = apply %16(%17, %18, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %21, %22
%21 = tuple_extract %20 : $(Builtin.Word, Builtin.Int1), 0 // user: %26
%22 = tuple_extract %20 : $(Builtin.Word, Builtin.Int1), 1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %26
%25 = struct_extract %12 : $Int, #Int.value // user: %26
%26 = apply %24(%25, %21, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %27, %28
%27 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 0 // user: %30
%28 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 1 // user: %29
cond_fail %28 : $Builtin.Int1 // id: %29
%30 = struct $Int (%27 : $Builtin.Word) // user: %38
// function_ref Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%31 = function_ref Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %32
%32 = apply %31<Value, Element>(%11) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %38
%33 = alloc_stack $Optional<HeapBufferStorage<Value, Element>> // users: %43, %46, %48
%34 = alloc_stack $HeapBufferStorage<Value, Element> // users: %41, %43, %45
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%35 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %41
%36 = alloc_stack $AnyObject // users: %39, %41, %44
// function_ref swift_bufferAllocate
%37 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %38
%38 = apply %37(%0, %30, %32) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %39
store %38 to %36#1 : $*AnyObject // id: %39
%40 = metatype $@thick HeapBufferStorage<Value, Element>.Type // user: %41
%41 = apply [transparent] %35<AnyObject, HeapBufferStorage<Value, Element>>(%34#1, %36#1, %40) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%42 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %43
%43 = apply [transparent] %42<HeapBufferStorage<Value, Element>>(%33#1, %34#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
dealloc_stack %36#0 : $*@local_storage AnyObject // id: %44
dealloc_stack %34#0 : $*@local_storage HeapBufferStorage<Value, Element> // id: %45
%46 = load %33#1 : $*Optional<HeapBufferStorage<Value, Element>> // users: %50, %52
release_value %8 : $Optional<HeapBufferStorage<Value, Element>> // id: %47
dealloc_stack %33#0 : $*@local_storage Optional<HeapBufferStorage<Value, Element>> // id: %48
// function_ref Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> ()
%49 = function_ref Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> () : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %56
%50 = struct $HeapBuffer<Value, Element> (%46 : $Optional<HeapBufferStorage<Value, Element>>) // users: %53, %59
// function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A>
%51 = function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %53
retain_value %46 : $Optional<HeapBufferStorage<Value, Element>> // id: %52
%53 = apply %51<Value, Element>(%50) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %56
%54 = alloc_stack $Value // users: %55, %56, %57
copy_addr %1 to [initialization] %54#1 : $*Value // id: %55
%56 = apply %49<Value>(%54#1, %53) : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
dealloc_stack %54#0 : $*@local_storage Value // id: %57
destroy_addr %1 : $*Value // id: %58
return %50 : $HeapBuffer<Value, Element> // id: %59
}
// Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
sil public_external Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> Int {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
%1 = function_ref Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Int // user: %3
retain_value %0 : $HeapBuffer<Value, Element> // id: %2
%3 = apply %1<Value, Element>(%0) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> Int // user: %8
// function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
%4 = function_ref Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %6
%5 = metatype $@thin HeapBuffer<Value, Element>.Type // user: %6
%6 = apply %4<Value, Element>(%5) : $@thin <τ_0_0, τ_0_1> (@thin HeapBuffer<τ_0_0, τ_0_1>.Type) -> Int // user: %9
%7 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %11
%8 = struct_extract %3 : $Int, #Int.value // user: %11
%9 = struct_extract %6 : $Int, #Int.value // user: %11
%10 = integer_literal $Builtin.Int1, -1 // user: %11
%11 = apply %7(%8, %9, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %12, %13
%12 = tuple_extract %11 : $(Builtin.Word, Builtin.Int1), 0 // users: %25, %32
%13 = tuple_extract %11 : $(Builtin.Word, Builtin.Int1), 1 // user: %14
cond_fail %13 : $Builtin.Int1 // id: %14
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%15 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %17
%16 = metatype $@thick Element.Type // user: %17
%17 = apply [transparent] %15<Element>(%16) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %21
release_value %0 : $HeapBuffer<Value, Element> // id: %18
%19 = integer_literal $Builtin.Word, 0 // user: %22
%20 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %22, %25, %27
%21 = struct_extract %17 : $Int, #Int.value // users: %22, %27, %32
%22 = apply %20(%21, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = integer_literal $Builtin.Word, -9223372036854775808 // user: %25
%25 = apply %20(%12, %24) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %29
%26 = integer_literal $Builtin.Word, -1 // user: %27
%27 = apply %20(%21, %26) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %29
%28 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %29
%29 = apply %28(%25, %27) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %30
cond_fail %29 : $Builtin.Int1 // id: %30
%31 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %32
%32 = apply %31(%12, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %33
%33 = struct $Int (%32 : $Builtin.Word) // user: %34
return %33 : $Int // id: %34
}
// Swift.HeapBuffer.value.setter : A
sil public_external Swift.HeapBuffer.value.setter : A : $@cc(method) @thin <Value, Element> (@in Value, @owned HeapBuffer<Value, Element>) -> () {
bb0(%0 : $*Value, %1 : $HeapBuffer<Value, Element>):
%2 = alloc_stack $Value // users: %3, %8, %10
copy_addr %0 to [initialization] %2#1 : $*Value // id: %3
// function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A>
%4 = function_ref Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %6
retain_value %1 : $HeapBuffer<Value, Element> // id: %5
%6 = apply %4<Value, Element>(%1) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<τ_0_0> // user: %8
// function_ref Swift.UnsafeMutablePointer.memory.setter : A
%7 = function_ref Swift.UnsafeMutablePointer.memory.setter : A : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %8
%8 = apply [transparent] %7<Value>(%2#1, %6) : $@cc(method) @thin <τ_0_0> (@in τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
release_value %1 : $HeapBuffer<Value, Element> // id: %9
dealloc_stack %2#0 : $*@local_storage Value // id: %10
destroy_addr %0 : $*Value // id: %11
%12 = tuple () // user: %13
return %12 : $() // id: %13
}
// Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil public_external Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin <Value, Element> (@thin HeapBuffer<Value, Element>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<Value, Element>.Type):
%1 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %7
%4 = integer_literal $Builtin.Word, 1 // users: %7, %14, %20
%5 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %7, %14, %20
%6 = integer_literal $Builtin.Int1, 0 // users: %7, %14, %20
%7 = apply %5(%3, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %8
%8 = tuple_extract %7 : $(Builtin.Word, Builtin.Int1), 0 // users: %9, %24, %28
%9 = struct $Int (%8 : $Builtin.Word) // user: %35
// function_ref Swift.alignof <A>(A.Type) -> Swift.Int
%10 = function_ref Swift.alignof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %12, %18
%11 = metatype $@thick Value.Type // user: %12
%12 = apply [transparent] %10<Value>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%13 = struct_extract %12 : $Int, #Int.value // user: %14
%14 = apply %5(%13, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %15
%15 = tuple_extract %14 : $(Builtin.Word, Builtin.Int1), 0 // users: %16, %24, %26
%16 = struct $Int (%15 : $Builtin.Word) // user: %31
%17 = metatype $@thick Element.Type // user: %18
%18 = apply [transparent] %10<Element>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %19
%19 = struct_extract %18 : $Int, #Int.value // user: %20
%20 = apply %5(%19, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %21
%21 = tuple_extract %20 : $(Builtin.Word, Builtin.Int1), 0 // users: %22, %26, %28
%22 = struct $Int (%21 : $Builtin.Word) // users: %30, %34
%23 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %24, %26, %28
%24 = apply %23(%8, %15) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
cond_br %24, bb1, bb2 // id: %25
bb1: // Preds: bb0
%26 = apply %23(%15, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %27
cond_br %26, bb3, bb4 // id: %27
bb2: // Preds: bb0
%28 = apply %23(%8, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %29
cond_br %28, bb6, bb7 // id: %29
bb3: // Preds: bb1
br bb5(%22 : $Int) // id: %30
bb4: // Preds: bb1
br bb5(%16 : $Int) // id: %31
bb5(%32 : $Int): // Preds: bb3 bb4 bb6 bb7
return %32 : $Int // id: %33
bb6: // Preds: bb2
br bb5(%22 : $Int) // id: %34
bb7: // Preds: bb2
br bb5(%9 : $Int) // id: %35
}
// Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
sil public_external Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin <Value, Element> (@owned HeapBuffer<Value, Element>) -> Int {
bb0(%0 : $HeapBuffer<Value, Element>):
// function_ref malloc_size
%1 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %7
// function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8>
%2 = function_ref Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8> : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %4
retain_value %0 : $HeapBuffer<Value, Element> // id: %3
%4 = apply %2<Value, Element>(%0) : $@cc(method) @thin <τ_0_0, τ_0_1> (@owned HeapBuffer<τ_0_0, τ_0_1>) -> UnsafeMutablePointer<Int8> // user: %5
%5 = struct_extract %4 : $UnsafeMutablePointer<Int8>, #UnsafeMutablePointer.value // user: %6
%6 = struct $UnsafePointer<()> (%5 : $Builtin.RawPointer) // user: %7
%7 = apply %1(%6) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %9
release_value %0 : $HeapBuffer<Value, Element> // id: %8
%9 = struct_extract %7 : $UInt, #UInt.value // user: %10
%10 = struct $Int (%9 : $Builtin.Word) // user: %11
return %10 : $Int // id: %11
}
// Swift.UnsafeMutablePointer.memory.setter : A
sil public_external [transparent] Swift.UnsafeMutablePointer.memory.setter : A : $@cc(method) @thin <T> (@in T, UnsafeMutablePointer<T>) -> () {
bb0(%0 : $*T, %1 : $UnsafeMutablePointer<T>):
%2 = alloc_stack $T // users: %3, %6, %7
copy_addr %0 to [initialization] %2#1 : $*T // id: %3
%4 = struct_extract %1 : $UnsafeMutablePointer<T>, #UnsafeMutablePointer.value // user: %5
%5 = pointer_to_address %4 : $Builtin.RawPointer to $*T // user: %6
copy_addr [take] %2#1 to %5 : $*T // id: %6
dealloc_stack %2#0 : $*@local_storage T // id: %7
destroy_addr %0 : $*T // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// malloc_size
sil @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt
// Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance
sil public_external Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance : $@thin <T where T : ForwardIndexType, T.Distance : _SignedIntegerType, T.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T.Distance, @in T, @in T) -> () {
bb0(%0 : $*T.Distance, %1 : $*T, %2 : $*T):
%3 = metatype $@thick T.Type // user: %14
%4 = witness_method $T, #ForwardIndexType."~>"!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Distance, @in τ_0_0, _Distance, @in τ_0_0, @thick τ_0_0.Type) -> () // user: %14
%5 = alloc_stack $T // users: %6, %14, %17
copy_addr %1 to [initialization] %5#1 : $*T // id: %6
// function_ref Swift._distanceTo <A>(A) -> (Swift._Distance, A)
%7 = function_ref Swift._distanceTo <A>(A) -> (Swift._Distance, A) : $@thin <τ_0_0> (@out (_Distance, τ_0_0), @in τ_0_0) -> () // user: %11
%8 = alloc_stack $T // users: %9, %11, %16
copy_addr %2 to [initialization] %8#1 : $*T // id: %9
%10 = alloc_stack $(_Distance, T) // users: %11, %13, %15
%11 = apply %7<T>(%10#1, %8#1) : $@thin <τ_0_0> (@out (_Distance, τ_0_0), @in τ_0_0) -> ()
%12 = struct $_Distance () // user: %14
%13 = tuple_element_addr %10#1 : $*(_Distance, T), 1 // user: %14
%14 = apply %4<T, T.Distance, T.Distance.IntegerLiteralType, T._DisabledRangeIndex>(%0, %5#1, %12, %13, %3) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : ForwardIndexType, τ_0_0.Distance : _SignedIntegerType, τ_0_0.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Distance, @in τ_0_0, _Distance, @in τ_0_0, @thick τ_0_0.Type) -> ()
dealloc_stack %10#0 : $*@local_storage (_Distance, T) // id: %15
dealloc_stack %8#0 : $*@local_storage T // id: %16
dealloc_stack %5#0 : $*@local_storage T // id: %17
destroy_addr %2 : $*T // id: %18
destroy_addr %1 : $*T // id: %19
%20 = tuple () // user: %21
return %20 : $() // id: %21
}
// Swift._distanceTo <A>(A) -> (Swift._Distance, A)
sil public_external Swift._distanceTo <A>(A) -> (Swift._Distance, A) : $@thin <I> (@out (_Distance, I), @in I) -> () {
bb0(%0 : $*(_Distance, I), %1 : $*I):
%2 = tuple_element_addr %0 : $*(_Distance, I), 0 // user: %5
%3 = tuple_element_addr %0 : $*(_Distance, I), 1 // user: %6
%4 = struct $_Distance () // user: %5
store %4 to %2 : $*_Distance // id: %5
copy_addr [take] %1 to [initialization] %3 : $*I // id: %6
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// protocol witness for Swift.Equatable.== infix <A : Swift.Equatable>(Swift.Equatable.Self.Type)(Swift.Equatable.Self, Swift.Equatable.Self) -> Swift.Bool in conformance Swift.Bool : Swift.Equatable
sil public_external protocol witness for Swift.Equatable.== infix <A : Swift.Equatable>(Swift.Equatable.Self.Type)(Swift.Equatable.Self, Swift.Equatable.Self) -> Swift.Bool in conformance Swift.Bool : Swift.Equatable : $@cc(witness_method) @thin (@in Bool, @in Bool, @thick Bool.Type) -> Bool {
bb0(%0 : $*Bool, %1 : $*Bool, %2 : $@thick Bool.Type):
%3 = struct_element_addr %0 : $*Bool, #Bool.value // user: %4
%4 = load %3 : $*Builtin.Int1 // user: %8
%5 = struct_element_addr %1 : $*Bool, #Bool.value // user: %6
%6 = load %5 : $*Builtin.Int1 // user: %8
%7 = builtin_function_ref "cmp_eq_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %8
%8 = apply %7(%4, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
%9 = struct $Bool (%8 : $Builtin.Int1) // user: %10
return %9 : $Bool // id: %10
}
// protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.LazyForwardCollection : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.LazyForwardCollection : Swift.CollectionType : $@cc(witness_method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>.Generator.Element, @in LazyForwardCollection<S>.Index, @inout LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Generator.Element, %1 : $*S.Index, %2 : $*LazyForwardCollection<S>):
%3 = alloc_stack $LazyForwardCollection<S> // users: %4, %6, %7
copy_addr %2 to [initialization] %3#1 : $*LazyForwardCollection<S> // id: %4
// function_ref Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element
%5 = function_ref Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %6
%6 = apply %5<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %1, %3#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @in LazyForwardCollection<τ_0_0>) -> () // user: %8
dealloc_stack %3#0 : $*@local_storage LazyForwardCollection<S> // id: %7
return %6 : $() // id: %8
}
// protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.LazyForwardCollection : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.LazyForwardCollection : Swift.CollectionType : $@cc(witness_method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out LazyForwardCollection<S>.Index.Distance, @in LazyForwardCollection<S>, _CountElements, @thick LazyForwardCollection<S>.Type) -> () {
bb0(%0 : $*S.Index.Distance, %1 : $*LazyForwardCollection<S>, %2 : $_CountElements, %3 : $@thick LazyForwardCollection<S>.Type):
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
%4 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %5
%5 = apply %4<LazyForwardCollection<S>, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S.Generator.Element>(%0, %1, %2) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %6
return %5 : $() // id: %6
}
// Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element
sil public_external Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element : $@cc(method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out S.Generator.Element, @in S.Index, @in LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Generator.Element, %1 : $*S.Index, %2 : $*LazyForwardCollection<S>):
%3 = struct_element_addr %2 : $*LazyForwardCollection<S>, #LazyForwardCollection._base // user: %7
%4 = alloc_stack $S.Index // users: %5, %7, %8
copy_addr %1 to [initialization] %4#1 : $*S.Index // id: %5
%6 = witness_method $S, #CollectionType.subscript!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> () // user: %7
%7 = apply %6<S, S.Generator, S.Generator.Element, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %4#1, %3) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> ()
dealloc_stack %4#0 : $*@local_storage S.Index // id: %8
destroy_addr %2 : $*LazyForwardCollection<S> // id: %9
destroy_addr %1 : $*S.Index // id: %10
%11 = tuple () // user: %12
return %11 : $() // id: %12
}
// Swift.LazyForwardCollection.startIndex.getter : A.Index
sil public_external Swift.LazyForwardCollection.startIndex.getter : A.Index : $@cc(method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out S.Index, @in LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Index, %1 : $*LazyForwardCollection<S>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<S>, #LazyForwardCollection._base // user: %4
%3 = witness_method $S, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %4
%4 = apply %3<S, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
destroy_addr %1 : $*LazyForwardCollection<S> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift.LazyForwardCollection.endIndex.getter : A.Index
sil public_external Swift.LazyForwardCollection.endIndex.getter : A.Index : $@cc(method) @thin <S where S : CollectionType, S.Generator : GeneratorType, S.Index : ForwardIndexType, S.Index.Distance : _SignedIntegerType, S.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out S.Index, @in LazyForwardCollection<S>) -> () {
bb0(%0 : $*S.Index, %1 : $*LazyForwardCollection<S>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<S>, #LazyForwardCollection._base // user: %4
%3 = witness_method $S, #_CollectionType.endIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %4
%4 = apply %3<S, S.Index, S.Index.Distance, S.Index.Distance.IntegerLiteralType, S.Index._DisabledRangeIndex, S._Element>(%0, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
destroy_addr %1 : $*LazyForwardCollection<S> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// protocol witness for Swift.Equatable.== infix <A : Swift.Equatable>(Swift.Equatable.Self.Type)(Swift.Equatable.Self, Swift.Equatable.Self) -> Swift.Bool in conformance Swift.Int : Swift.Equatable
sil public_external protocol witness for Swift.Equatable.== infix <A : Swift.Equatable>(Swift.Equatable.Self.Type)(Swift.Equatable.Self, Swift.Equatable.Self) -> Swift.Bool in conformance Swift.Int : Swift.Equatable : $@cc(witness_method) @thin (@in Int, @in Int, @thick Int.Type) -> Bool {
bb0(%0 : $*Int, %1 : $*Int, %2 : $@thick Int.Type):
%3 = struct_element_addr %0 : $*Int, #Int.value // user: %4
%4 = load %3 : $*Builtin.Word // user: %8
%5 = struct_element_addr %1 : $*Int, #Int.value // user: %6
%6 = load %5 : $*Builtin.Word // user: %8
%7 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %8
%8 = apply %7(%4, %6) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%9 = struct $Bool (%8 : $Builtin.Int1) // user: %10
return %9 : $Bool // id: %10
}
// protocol witness for Swift._Incrementable.successor <A : Swift._Incrementable>(inout Swift._Incrementable.Self)() -> Swift._Incrementable.Self in conformance Swift.Int : Swift._Incrementable
sil public_external protocol witness for Swift._Incrementable.successor <A : Swift._Incrementable>(inout Swift._Incrementable.Self)() -> Swift._Incrementable.Self in conformance Swift.Int : Swift._Incrementable : $@cc(witness_method) @thin (@out Int, @inout Int) -> () {
bb0(%0 : $*Int, %1 : $*Int):
%2 = struct_element_addr %1 : $*Int, #Int.value // user: %3
%3 = load %2 : $*Builtin.Word // user: %7
%4 = integer_literal $Builtin.Word, 1 // user: %7
%5 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %7
%6 = integer_literal $Builtin.Int1, 0 // user: %7
%7 = apply %5(%3, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %8
%8 = tuple_extract %7 : $(Builtin.Word, Builtin.Int1), 0 // user: %9
%9 = struct $Int (%8 : $Builtin.Word) // user: %10
store %9 to %0 : $*Int // id: %10
%11 = tuple () // user: %12
return %11 : $() // id: %12
}
// protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.Array : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.Array : Swift.SequenceType : $@cc(witness_method) @thin <T> (@out Array<T>.Generator, @inout Array<T>) -> () {
bb0(%0 : $*IndexingGenerator<Array<T>>, %1 : $*Array<T>):
%2 = load %1 : $*Array<T> // users: %3, %7
%3 = struct_extract %2 : $Array<T>, #Array._buffer // user: %4
%4 = struct_extract %3 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %6
// function_ref Swift.Array.generate <A>(Swift.Array<A>)() -> Swift.IndexingGenerator<Swift.Array<A>>
%5 = function_ref Swift.Array.generate <A>([A])() -> Swift.IndexingGenerator<[A]> : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> @owned IndexingGenerator<Array<τ_0_0>> // user: %7
retain_value %4 : $Optional<Builtin.NativeObject> // id: %6
%7 = apply %5<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> @owned IndexingGenerator<Array<τ_0_0>> // user: %8
store %7 to %0 : $*IndexingGenerator<Array<T>> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._UnderestimateCount, ())) -> Swift.Int in conformance Swift.Array : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._UnderestimateCount, ())) -> Swift.Int in conformance Swift.Array : Swift.SequenceType : $@cc(witness_method) @thin <T> (@in Array<T>, _UnderestimateCount, @thick Array<T>.Type) -> Int {
bb0(%0 : $*Array<T>, %1 : $_UnderestimateCount, %2 : $@thick Array<T>.Type):
%3 = load %0 : $*Array<T> // user: %5
%4 = alloc_stack $Array<T> // users: %5, %7, %8
store %3 to %4#1 : $*Array<T> // id: %5
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int
%6 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0, _UnderestimateCount) -> Int // user: %7
%7 = apply %6<[T], Int, Int, Int, Int, T>(%4#1, %1) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in τ_0_0, _UnderestimateCount) -> Int // user: %9
dealloc_stack %4#0 : $*@local_storage Array<T> // id: %8
return %7 : $Int // id: %9
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)<C>(Swift.SequenceType.Self, (Swift._PreprocessingPass, (Swift.SequenceType.Self) -> C)) -> Swift.Optional<C> in conformance Swift.Array : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)<C>(Swift.SequenceType.Self, (Swift._PreprocessingPass, (Swift.SequenceType.Self) -> C)) -> C? in conformance Swift.Array : Swift.SequenceType : $@cc(witness_method) @thin <T><R> (@out Optional<R>, @in Array<T>, _PreprocessingPass, @owned @callee_owned (@out R, @in Array<T>) -> (), @thick Array<T>.Type) -> () {
bb0(%0 : $*Optional<R>, %1 : $*Array<T>, %2 : $_PreprocessingPass, %3 : $@callee_owned (@out R, @in Array<T>) -> (), %4 : $@thick Array<T>.Type):
%5 = load %1 : $*Array<T> // user: %9
// function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.Array<T_0_0>) -> (@out T_1_0) to @callee_owned (@owned Swift.Array<T_0_0>) -> (@out T_1_0)
%6 = function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in [T_0_0]) -> (@out T_1_0) to @callee_owned (@owned [T_0_0]) -> (@out T_1_0) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @owned Array<τ_0_0>, @owned @callee_owned (@out τ_1_0, @in Array<τ_0_0>) -> ()) -> () // user: %7
%7 = partial_apply %6<T, R>(%3) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @owned Array<τ_0_0>, @owned @callee_owned (@out τ_1_0, @in Array<τ_0_0>) -> ()) -> () // user: %11
%8 = alloc_stack $Array<T> // users: %9, %13, %14
store %5 to %8#1 : $*Array<T> // id: %9
// function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@owned Swift.Array<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.Array<T_0_0>) -> (@out T_1_0)
%10 = function_ref reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@owned [T_0_0]) -> (@out T_1_0) to @callee_owned (@in [T_0_0]) -> (@out T_1_0) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @in Array<τ_0_0>, @owned @callee_owned (@out τ_1_0, @owned Array<τ_0_0>) -> ()) -> () // user: %11
%11 = partial_apply %10<T, R>(%7) : $@thin <τ_0_0><τ_1_0> (@out τ_1_0, @in Array<τ_0_0>, @owned @callee_owned (@out τ_1_0, @owned Array<τ_0_0>) -> ()) -> () // user: %13
// function_ref Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> Swift.Optional<B>
%12 = function_ref Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> B? : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_1>, @in τ_0_0, _PreprocessingPass, @owned @callee_owned (@out τ_0_1, @in τ_0_0) -> ()) -> () // user: %13
%13 = apply %12<[T], R, Int, Int, Int, Int, T>(%0, %8#1, %2, %11) : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_1>, @in τ_0_0, _PreprocessingPass, @owned @callee_owned (@out τ_0_1, @in τ_0_0) -> ()) -> () // user: %15
dealloc_stack %8#0 : $*@local_storage Array<T> // id: %14
return %13 : $() // id: %15
}
// protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.Array : Swift.SequenceType
sil public_external protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.Array : Swift.SequenceType : $@cc(witness_method) @thin <T> (@in Array<T>, _CopyToNativeArrayBuffer, @thick Array<T>.Type) -> @owned _ContiguousArrayBuffer<Array<T>.Generator.Element> {
bb0(%0 : $*Array<T>, %1 : $_CopyToNativeArrayBuffer, %2 : $@thick Array<T>.Type):
%3 = load %0 : $*Array<T> // user: %5
%4 = alloc_stack $Array<T> // users: %5, %7, %8
store %3 to %4#1 : $*Array<T> // id: %5
// function_ref Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element>
%6 = function_ref Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %7
%7 = apply %6<[T], IndexingGenerator<Array<T>>, T, Int, Int, Int, Int>(%4#1, %1) : $@thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_0.Generator.Element == τ_0_0._Element> (@in τ_0_0, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0.Generator.Element> // user: %9
dealloc_stack %4#0 : $*@local_storage Array<T> // id: %8
return %7 : $_ContiguousArrayBuffer<T> // id: %9
}
// Swift.Array.generate <A>(Swift.Array<A>)() -> Swift.IndexingGenerator<Swift.Array<A>>
sil public_external Swift.Array.generate <A>([A])() -> Swift.IndexingGenerator<[A]> : $@cc(method) @thin <T> (@owned Array<T>) -> @owned IndexingGenerator<Array<T>> {
bb0(%0 : $Array<T>):
// function_ref Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A>
%1 = function_ref Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A> : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out IndexingGenerator<τ_0_0>, @in τ_0_0, @thin IndexingGenerator<τ_0_0>.Type) -> () // user: %6
%2 = metatype $@thin IndexingGenerator<Array<T>>.Type // user: %6
%3 = alloc_stack $Array<T> // users: %4, %6, %9
store %0 to %3#1 : $*Array<T> // id: %4
%5 = alloc_stack $IndexingGenerator<Array<T>> // users: %6, %7, %8
%6 = apply %1<[T], Int, Int, Int, Int, T>(%5#1, %3#1, %2) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out IndexingGenerator<τ_0_0>, @in τ_0_0, @thin IndexingGenerator<τ_0_0>.Type) -> ()
%7 = load %5#1 : $*IndexingGenerator<Array<T>> // user: %10
dealloc_stack %5#0 : $*@local_storage IndexingGenerator<Array<T>> // id: %8
dealloc_stack %3#0 : $*@local_storage Array<T> // id: %9
return %7 : $IndexingGenerator<Array<T>> // id: %10
}
// Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A>
sil public_external Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A> : $@thin <C where C : _CollectionType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out IndexingGenerator<C>, @in C, @thin IndexingGenerator<C>.Type) -> () {
bb0(%0 : $*IndexingGenerator<C>, %1 : $*C, %2 : $@thin IndexingGenerator<C>.Type):
%3 = alloc_stack $IndexingGenerator<C> // users: %6, %12, %16, %18
%4 = alloc_stack $C // users: %5, %7, %8
copy_addr %1 to [initialization] %4#1 : $*C // id: %5
%6 = struct_element_addr %3#1 : $*IndexingGenerator<C>, #IndexingGenerator._elements // user: %7
copy_addr [take] %4#1 to [initialization] %6 : $*C // id: %7
dealloc_stack %4#0 : $*@local_storage C // id: %8
%9 = witness_method $C, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %11
%10 = alloc_stack $C.Index // users: %11, %13, %14
%11 = apply %9<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%10#1, %1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%12 = struct_element_addr %3#1 : $*IndexingGenerator<C>, #IndexingGenerator._position // user: %13
copy_addr [take] %10#1 to [initialization] %12 : $*C.Index // id: %13
dealloc_stack %10#0 : $*@local_storage C.Index // id: %14
destroy_addr %1 : $*C // id: %15
copy_addr [take] %3#1 to [initialization] %0 : $*IndexingGenerator<C> // id: %16
%17 = tuple () // user: %19
dealloc_stack %3#0 : $*@local_storage IndexingGenerator<C> // id: %18
return %17 : $() // id: %19
}
// protocol witness for Swift.GeneratorType.next <A : Swift.GeneratorType>(inout Swift.GeneratorType.Self)() -> Swift.Optional<Swift.GeneratorType.Self.Element> in conformance Swift.IndexingGenerator : Swift.GeneratorType
sil public_external protocol witness for Swift.GeneratorType.next <A : Swift.GeneratorType>(inout Swift.GeneratorType.Self)() -> Swift.GeneratorType.Self.Element? in conformance Swift.IndexingGenerator : Swift.GeneratorType : $@cc(witness_method) @thin <C where C : _CollectionType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<IndexingGenerator<C>.Element>, @inout IndexingGenerator<C>) -> () {
bb0(%0 : $*Optional<C._Element>, %1 : $*IndexingGenerator<C>):
// function_ref Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> Swift.Optional<A._Element>
%2 = function_ref Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> A._Element? : $@cc(method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0._Element>, @inout IndexingGenerator<τ_0_0>) -> () // user: %3
%3 = apply %2<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%0, %1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0._Element>, @inout IndexingGenerator<τ_0_0>) -> () // user: %4
return %3 : $() // id: %4
}
// Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> Swift.Optional<A._Element>
sil public_external Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> A._Element? : $@cc(method) @thin <C where C : _CollectionType, C.Index : ForwardIndexType, C.Index.Distance : _SignedIntegerType, C.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<C._Element>, @inout IndexingGenerator<C>) -> () {
bb0(%0 : $*Optional<C._Element>, %1 : $*IndexingGenerator<C>):
%2 = metatype $@thick C.Index.Type // user: %11
%3 = witness_method $C.Index, #Equatable."=="!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %11
%4 = alloc_stack $C.Index // users: %6, %11, %14
%5 = struct_element_addr %1 : $*IndexingGenerator<C>, #IndexingGenerator._position // users: %6, %25
copy_addr %5 to [initialization] %4#1 : $*C.Index // id: %6
%7 = alloc_stack $C.Index // users: %10, %11, %13
%8 = struct_element_addr %1 : $*IndexingGenerator<C>, #IndexingGenerator._elements // users: %10, %27
%9 = witness_method $C, #_CollectionType.endIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %10
%10 = apply %9<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%7#1, %8) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
%11 = apply %3<C.Index>(%4#1, %7#1, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : Equatable> (@in τ_0_0, @in τ_0_0, @thick τ_0_0.Type) -> Bool // user: %12
%12 = struct_extract %11 : $Bool, #Bool.value // user: %15
dealloc_stack %7#0 : $*@local_storage C.Index // id: %13
dealloc_stack %4#0 : $*@local_storage C.Index // id: %14
cond_br %12, bb1, bb2 // id: %15
bb1: // Preds: bb0
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%16 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %18
%17 = metatype $@thin Optional<C._Element>.Type // user: %18
%18 = apply [transparent] %16<C._Element>(%0, %17) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
br bb3 // id: %19
bb2: // Preds: bb0
// function_ref Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
%20 = function_ref Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> () // user: %28
%21 = metatype $@thin Optional<C._Element>.Type // user: %28
%22 = alloc_stack $C._Element // users: %27, %28, %30
// function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
%23 = function_ref Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> () // user: %25
%24 = alloc_stack $C.Index // users: %25, %27, %29
%25 = apply [transparent] %23<C.Index>(%24#1, %5) : $@thin <τ_0_0 where τ_0_0 : _Incrementable> (@out τ_0_0, @inout τ_0_0) -> ()
%26 = witness_method $C, #_CollectionType.subscript!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0._Element, @in τ_0_0.Index, @inout τ_0_0) -> () // user: %27
%27 = apply %26<C, C.Index, C.Index.Distance, C.Index.Distance.IntegerLiteralType, C.Index._DisabledRangeIndex, C._Element>(%22#1, %24#1, %8) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0._Element, @in τ_0_0.Index, @inout τ_0_0) -> ()
%28 = apply [transparent] %20<C._Element>(%0, %22#1, %21) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> ()
dealloc_stack %24#0 : $*@local_storage C.Index // id: %29
dealloc_stack %22#0 : $*@local_storage C._Element // id: %30
br bb3 // id: %31
bb3: // Preds: bb1 bb2
%32 = tuple () // user: %33
return %32 : $() // id: %33
}
// Swift.UnsafePointer.value.getter : Builtin.RawPointer
sil public_external [transparent] Swift.UnsafePointer.value.getter : Builtin.RawPointer : $@cc(method) @thin <T> (UnsafePointer<T>) -> Builtin.RawPointer {
bb0(%0 : $UnsafePointer<T>):
%1 = struct_extract %0 : $UnsafePointer<T>, #UnsafePointer.value // user: %2
return %1 : $Builtin.RawPointer // id: %2
}
// Swift.UnsafeBufferPointer.generate <A>(Swift.UnsafeBufferPointer<A>)() -> Swift.UnsafeBufferPointerGenerator<A>
sil public_external Swift.UnsafeBufferPointer.generate <A>(Swift.UnsafeBufferPointer<A>)() -> Swift.UnsafeBufferPointerGenerator<A> : $@cc(method) @thin <T> (UnsafeBufferPointer<T>) -> UnsafeBufferPointerGenerator<T> {
bb0(%0 : $UnsafeBufferPointer<T>):
// function_ref Swift.UnsafeBufferPointerGenerator.init <A>(Swift.UnsafeBufferPointerGenerator<A>.Type)(position : Swift.UnsafePointer<A>, end : Swift.UnsafePointer<A>) -> Swift.UnsafeBufferPointerGenerator<A>
%1 = function_ref Swift.UnsafeBufferPointerGenerator.init <A>(Swift.UnsafeBufferPointerGenerator<A>.Type)(position : Swift.UnsafePointer<A>, end : Swift.UnsafePointer<A>) -> Swift.UnsafeBufferPointerGenerator<A> : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, UnsafePointer<τ_0_0>, @thin UnsafeBufferPointerGenerator<τ_0_0>.Type) -> UnsafeBufferPointerGenerator<τ_0_0> // user: %5
%2 = metatype $@thin UnsafeBufferPointerGenerator<T>.Type // user: %5
%3 = struct_extract %0 : $UnsafeBufferPointer<T>, #UnsafeBufferPointer._position // user: %5
%4 = struct_extract %0 : $UnsafeBufferPointer<T>, #UnsafeBufferPointer._end // user: %5
%5 = apply %1<T>(%3, %4, %2) : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, UnsafePointer<τ_0_0>, @thin UnsafeBufferPointerGenerator<τ_0_0>.Type) -> UnsafeBufferPointerGenerator<τ_0_0> // user: %6
return %5 : $UnsafeBufferPointerGenerator<T> // id: %6
}
// Swift.UnsafeBufferPointerGenerator.init <A>(Swift.UnsafeBufferPointerGenerator<A>.Type)(position : Swift.UnsafePointer<A>, end : Swift.UnsafePointer<A>) -> Swift.UnsafeBufferPointerGenerator<A>
sil public_external Swift.UnsafeBufferPointerGenerator.init <A>(Swift.UnsafeBufferPointerGenerator<A>.Type)(position : Swift.UnsafePointer<A>, end : Swift.UnsafePointer<A>) -> Swift.UnsafeBufferPointerGenerator<A> : $@thin <T> (UnsafePointer<T>, UnsafePointer<T>, @thin UnsafeBufferPointerGenerator<T>.Type) -> UnsafeBufferPointerGenerator<T> {
bb0(%0 : $UnsafePointer<T>, %1 : $UnsafePointer<T>, %2 : $@thin UnsafeBufferPointerGenerator<T>.Type):
%3 = struct $UnsafeBufferPointerGenerator<T> (%0 : $UnsafePointer<T>, %1 : $UnsafePointer<T>) // user: %4
return %3 : $UnsafeBufferPointerGenerator<T> // id: %4
}
// Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int
sil public_external Swift.~> infix <A : Swift._CollectionType>(A, (Swift._UnderestimateCount, ())) -> Swift.Int : $@thin <T where T : _CollectionType, T.Index : ForwardIndexType, T.Index.Distance : _SignedIntegerType, T.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@in T, _UnderestimateCount) -> Int {
bb0(%0 : $*T, %1 : $_UnderestimateCount):
// function_ref Swift.numericCast <A : Swift._SignedIntegerType, B : Swift._SignedIntegerType>(A) -> B
%2 = function_ref Swift.numericCast <A : Swift._SignedIntegerType, B : Swift._SignedIntegerType>(A) -> B : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _SignedIntegerType, τ_0_1 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_1.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0) -> () // user: %10
%3 = alloc_stack $T.Index.Distance // users: %8, %10, %14
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
%4 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %8
%5 = alloc_stack $T // users: %6, %8, %13
copy_addr %0 to [initialization] %5#1 : $*T // id: %6
%7 = struct $_CountElements () // user: %8
%8 = apply %4<T, T.Index, T.Index.Distance, T.Index.Distance.IntegerLiteralType, T.Index._DisabledRangeIndex, T._Element>(%3#1, %5#1, %7) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> ()
%9 = alloc_stack $Int // users: %10, %11, %12
%10 = apply %2<T.Index.Distance, Int, T.Index.Distance.IntegerLiteralType, Int>(%9#1, %3#1) : $@thin <τ_0_0, τ_0_1 where τ_0_0 : _SignedIntegerType, τ_0_1 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, τ_0_1.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0) -> ()
%11 = load %9#1 : $*Int // user: %16
dealloc_stack %9#0 : $*@local_storage Int // id: %12
dealloc_stack %5#0 : $*@local_storage T // id: %13
dealloc_stack %3#0 : $*@local_storage T.Index.Distance // id: %14
destroy_addr %0 : $*T // id: %15
return %11 : $Int // id: %16
}
// Swift.numericCast <A : Swift._SignedIntegerType, B : Swift._SignedIntegerType>(A) -> B
sil public_external Swift.numericCast <A : Swift._SignedIntegerType, B : Swift._SignedIntegerType>(A) -> B : $@thin <T, U where T : _SignedIntegerType, U : _SignedIntegerType, T.IntegerLiteralType : _BuiltinIntegerLiteralConvertible, U.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out U, @in T) -> () {
bb0(%0 : $*U, %1 : $*T):
%2 = metatype $@thick U.Type // user: %6
%3 = witness_method $U, #_SignedIntegerType.init!allocator.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, Int64, @thick τ_0_0.Type) -> () // user: %6
%4 = witness_method $T, #_SignedIntegerType.toIntMax!1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@inout τ_0_0) -> Int64 // user: %5
%5 = apply %4<T, T.IntegerLiteralType>(%1) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@inout τ_0_0) -> Int64 // user: %6
%6 = apply %3<U, U.IntegerLiteralType>(%0, %5, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _SignedIntegerType, τ_0_0.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0, Int64, @thick τ_0_0.Type) -> ()
destroy_addr %1 : $*T // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0)
sil shared_external [transparent] reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) : $@thin <T><R> (@out R, UnsafeBufferPointer<T>, @owned @callee_owned (@out R, @in UnsafeBufferPointer<T>) -> ()) -> () {
bb0(%0 : $*R, %1 : $UnsafeBufferPointer<T>, %2 : $@callee_owned (@out R, @in UnsafeBufferPointer<T>) -> ()):
%3 = alloc_stack $UnsafeBufferPointer<T> // users: %4, %5, %6
store %1 to %3#1 : $*UnsafeBufferPointer<T> // id: %4
%5 = apply %2(%0, %3#1) : $@callee_owned (@out R, @in UnsafeBufferPointer<T>) -> () // user: %7
dealloc_stack %3#0 : $*@local_storage UnsafeBufferPointer<T> // id: %6
return %5 : $() // id: %7
}
// reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0)
sil shared_external [transparent] reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@unowned Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.UnsafeBufferPointer<T_0_0>) -> (@out T_1_0) : $@thin <T><R> (@out R, @in UnsafeBufferPointer<T>, @owned @callee_owned (@out R, UnsafeBufferPointer<T>) -> ()) -> () {
bb0(%0 : $*R, %1 : $*UnsafeBufferPointer<T>, %2 : $@callee_owned (@out R, UnsafeBufferPointer<T>) -> ()):
%3 = load %1 : $*UnsafeBufferPointer<T> // user: %4
%4 = apply %2(%0, %3) : $@callee_owned (@out R, UnsafeBufferPointer<T>) -> () // user: %5
return %4 : $() // id: %5
}
// Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> Swift.Optional<B>
sil public_external Swift.~> infix <A : Swift._CollectionType, B>(A, (Swift._PreprocessingPass, (A) -> B)) -> B? : $@thin <T, R where T : _CollectionType, T.Index : ForwardIndexType, T.Index.Distance : _SignedIntegerType, T.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<R>, @in T, _PreprocessingPass, @owned @callee_owned (@out R, @in T) -> ()) -> () {
bb0(%0 : $*Optional<R>, %1 : $*T, %2 : $_PreprocessingPass, %3 : $@callee_owned (@out R, @in T) -> ()):
%4 = alloc_stack $R // users: %8, %10, %13
%5 = alloc_stack $T // users: %6, %8, %12
copy_addr %1 to [initialization] %5#1 : $*T // id: %6
strong_retain %3 : $@callee_owned (@out R, @in T) -> () // id: %7
%8 = apply %3(%4#1, %5#1) : $@callee_owned (@out R, @in T) -> ()
// function_ref Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
%9 = function_ref Swift._injectValueIntoOptional <A>(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> () // user: %10
%10 = apply [transparent] %9<R>(%0, %4#1) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0) -> ()
strong_release %3 : $@callee_owned (@out R, @in T) -> () // id: %11
dealloc_stack %5#0 : $*@local_storage T // id: %12
dealloc_stack %4#0 : $*@local_storage R // id: %13
destroy_addr %1 : $*T // id: %14
%15 = tuple () // user: %16
return %15 : $() // id: %16
}
// reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in Swift.Array<T_0_0>) -> (@out T_1_0) to @callee_owned (@owned Swift.Array<T_0_0>) -> (@out T_1_0)
sil shared_external [transparent] reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@in [T_0_0]) -> (@out T_1_0) to @callee_owned (@owned [T_0_0]) -> (@out T_1_0) : $@thin <T><R> (@out R, @owned Array<T>, @owned @callee_owned (@out R, @in Array<T>) -> ()) -> () {
bb0(%0 : $*R, %1 : $Array<T>, %2 : $@callee_owned (@out R, @in Array<T>) -> ()):
%3 = alloc_stack $Array<T> // users: %4, %5, %6
store %1 to %3#1 : $*Array<T> // id: %4
%5 = apply %2(%0, %3#1) : $@callee_owned (@out R, @in Array<T>) -> () // user: %7
dealloc_stack %3#0 : $*@local_storage Array<T> // id: %6
return %5 : $() // id: %7
}
// reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@owned Swift.Array<T_0_0>) -> (@out T_1_0) to @callee_owned (@in Swift.Array<T_0_0>) -> (@out T_1_0)
sil shared_external [transparent] reabstraction thunk helper <T_0_0, T_1_0> from @callee_owned (@owned [T_0_0]) -> (@out T_1_0) to @callee_owned (@in [T_0_0]) -> (@out T_1_0) : $@thin <T><R> (@out R, @in Array<T>, @owned @callee_owned (@out R, @owned Array<T>) -> ()) -> () {
bb0(%0 : $*R, %1 : $*Array<T>, %2 : $@callee_owned (@out R, @owned Array<T>) -> ()):
%3 = load %1 : $*Array<T> // user: %4
%4 = apply %2(%0, %3) : $@callee_owned (@out R, @owned Array<T>) -> () // user: %5
return %4 : $() // id: %5
}
// specialization <Swift.Optional<Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>>, Swift.Optional<Swift._ContiguousArrayStorage<Swift.Int>>> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B
sil shared [transparent] specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>?, Swift._ContiguousArrayStorage<Swift.Int>?> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin (@out Optional<_ContiguousArrayStorage<Int>>, @in Optional<HeapBufferStorage<_ArrayBody, Int>>, @thick Optional<_ContiguousArrayStorage<Int>>.Type) -> () {
bb0(%0 : $*Optional<_ContiguousArrayStorage<Int>>, %1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %2 : $@thick Optional<_ContiguousArrayStorage<Int>>.Type):
%3 = alloc_stack $Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %5, %21, %25, %28
%4 = load %1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %5
store %4 to %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %5
%6 = integer_literal $Builtin.Int1, -1 // user: %17
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%7 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %9, %11
%8 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %9
%9 = apply [transparent] %7<HeapBufferStorage<_ArrayBody, Int>?>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%10 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %11
%11 = apply [transparent] %7<_ContiguousArrayStorage<Int>?>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %14
%12 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %15
%13 = struct_extract %9 : $Int, #Int.value // user: %15
%14 = struct_extract %11 : $Int, #Int.value // user: %15
%15 = apply %12(%13, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%19 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
%20 = metatype $@thin UnsafeMutablePointer<Optional<_ContiguousArrayStorage<Int>>>.Type // user: %22
%21 = address_to_pointer %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.RawPointer // user: %22
%22 = apply [transparent] %19<_ContiguousArrayStorage<Int>?>(%21, %20) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %24
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%23 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %24
%24 = apply [transparent] %23<_ContiguousArrayStorage<Int>?>(%0, %22) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
%25 = load %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %26
release_value %25 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %26
%27 = tuple () // user: %29
dealloc_stack %3#0 : $*@local_storage Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %28
return %27 : $() // id: %29
}
// specialization <Swift.Int> of protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.UnsafeBufferPointer : Swift.SequenceType
sil shared specialization <Swift.Int> of protocol witness for Swift.SequenceType.~> infix <A : Swift.SequenceType>(Swift.SequenceType.Self.Type)(Swift.SequenceType.Self, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<Swift.SequenceType.Self.Generator.Element> in conformance Swift.UnsafeBufferPointer : Swift.SequenceType : $@cc(witness_method) @thin (@in UnsafeBufferPointer<Int>, _CopyToNativeArrayBuffer, @thick UnsafeBufferPointer<Int>.Type) -> @owned _ContiguousArrayBuffer<Int> {
bb0(%0 : $*UnsafeBufferPointer<Int>, %1 : $_CopyToNativeArrayBuffer, %2 : $@thick UnsafeBufferPointer<Int>.Type):
%3 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %4
%4 = struct_element_addr %3 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %5
%5 = load %4 : $*Builtin.RawPointer // users: %13, %185
%6 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %7
%7 = struct_element_addr %6 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %8
%8 = load %7 : $*Builtin.RawPointer // user: %12
%9 = integer_literal $Builtin.Word, 0 // users: %19, %31, %41, %42, %133, %134, %161, %170, %173, %176, %176
%10 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %14
%11 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %12, %13
%12 = apply %11(%8) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %14
%13 = apply %11(%5) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %14
%14 = apply %10(%12, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %22, %29
%15 = metatype $@thick Int.Type // users: %17, %72
%16 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %17, %128
%17 = apply %16<Int>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %19, %24, %29, %84, %148, %182
%18 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %19, %22, %24, %31, %111, %122, %145, %173, %190
%19 = apply %18(%17, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %20
cond_fail %19 : $Builtin.Int1 // id: %20
%21 = integer_literal $Builtin.Word, -9223372036854775808 // users: %22, %145
%22 = apply %18(%14, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %26
%23 = integer_literal $Builtin.Word, -1 // users: %24, %64, %81
%24 = apply %18(%17, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %26, %146
%25 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %26, %146
%26 = apply %25(%22, %24) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %27
cond_fail %26 : $Builtin.Int1 // id: %27
%28 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %29, %148
%29 = apply %28(%14, %17) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %31, %37, %41, %43, %170, %173, %190
%30 = integer_literal $Builtin.Int1, 0 // users: %59, %61, %77, %79, %94, %129, %166, %180, %183
%31 = apply %18(%29, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %32
cond_br %31, bb1, bb2 // id: %32
bb1: // Preds: bb0
%33 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %34
%34 = struct $HeapBuffer<_ArrayBody, Int> (%33 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %35
%35 = struct $_ContiguousArrayBuffer<Int> (%34 : $HeapBuffer<_ArrayBody, Int>) // user: %36
br bb15(%35 : $_ContiguousArrayBuffer<Int>) // id: %36
bb2: // Preds: bb0
%37 = struct $Int (%29 : $Builtin.Word) // user: %163
%38 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %39
%39 = upcast %38 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %106
%40 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %41, %99, %101, %193
%41 = apply %40(%9, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %42
cond_br %41, bb3, bb4(%9 : $Builtin.Word) // id: %42
bb3: // Preds: bb2
br bb4(%29 : $Builtin.Word) // id: %43
bb4(%44 : $Builtin.Word): // Preds: bb2 bb3
%45 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %47, %67, %108, %110, %119, %121
%46 = metatype $@thick HeapObject.Type // users: %47, %93
%47 = apply %45<HeapObject>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %53
%48 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %50, %72, %93
%49 = metatype $@thick _ArrayBody.Type // users: %50, %67
%50 = apply %48<_ArrayBody>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %53, %61
%51 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %53, %68, %73, %88, %180, %183
%52 = integer_literal $Builtin.Int1, -1 // users: %53, %68, %73, %84, %88, %113, %123, %141, %171
%53 = apply %51(%47, %50, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %54, %55
%54 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 0 // user: %59
%55 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 1 // user: %56
cond_fail %55 : $Builtin.Int1 // id: %56
%57 = integer_literal $Builtin.Word, 1 // users: %59, %61, %77, %79, %94, %159, %180, %183
%58 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %59, %61, %77, %79, %94, %141
%59 = apply %58(%54, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %60
%60 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%61 = apply %58(%50, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %62
%62 = tuple_extract %61 : $(Builtin.Word, Builtin.Int1), 0 // users: %64, %97, %99, %101
%63 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %64, %81
%64 = apply %63(%62, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %66
%65 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %66, %82
%66 = apply %65(%60, %64) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %68, %129
%67 = apply %45<_ArrayBody>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %68
%68 = apply %51(%66, %67, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %69, %70
%69 = tuple_extract %68 : $(Builtin.Word, Builtin.Int1), 0 // user: %73
%70 = tuple_extract %68 : $(Builtin.Word, Builtin.Int1), 1 // user: %71
cond_fail %70 : $Builtin.Int1 // id: %71
%72 = apply %48<Int>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %73, %79
%73 = apply %51(%69, %72, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %74, %75
%74 = tuple_extract %73 : $(Builtin.Word, Builtin.Int1), 0 // user: %77
%75 = tuple_extract %73 : $(Builtin.Word, Builtin.Int1), 1 // user: %76
cond_fail %75 : $Builtin.Int1 // id: %76
%77 = apply %58(%74, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %78
%78 = tuple_extract %77 : $(Builtin.Word, Builtin.Int1), 0 // user: %82
%79 = apply %58(%72, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %80
%80 = tuple_extract %79 : $(Builtin.Word, Builtin.Int1), 0 // users: %81, %98, %101, %193
%81 = apply %63(%80, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %82
%82 = apply %65(%78, %81) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %88, %141, %166
%83 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %84, %129, %166
%84 = apply %83(%44, %17, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %85, %86
%85 = tuple_extract %84 : $(Builtin.Word, Builtin.Int1), 0 // user: %88
%86 = tuple_extract %84 : $(Builtin.Word, Builtin.Int1), 1 // user: %87
cond_fail %86 : $Builtin.Int1 // id: %87
%88 = apply %51(%82, %85, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %89, %90
%89 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 0 // user: %92
%90 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 1 // user: %91
cond_fail %90 : $Builtin.Int1 // id: %91
%92 = struct $Int (%89 : $Builtin.Word) // user: %106
%93 = apply %48<HeapObject>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %94
%94 = apply %58(%93, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %95
%95 = tuple_extract %94 : $(Builtin.Word, Builtin.Int1), 0 // users: %96, %99, %193
%96 = struct $Int (%95 : $Builtin.Word) // user: %196
%97 = struct $Int (%62 : $Builtin.Word) // user: %192
%98 = struct $Int (%80 : $Builtin.Word) // users: %103, %195
%99 = apply %40(%95, %62) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %100
cond_br %99, bb5, bb12 // id: %100
bb5: // Preds: bb4
%101 = apply %40(%62, %80) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %102
cond_br %101, bb6, bb11 // id: %102
bb6: // Preds: bb5
br bb7(%98 : $Int) // id: %103
bb7(%104 : $Int): // Preds: bb6 bb11 bb13 bb14
// function_ref swift_bufferAllocate
%105 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %106
%106 = apply %105(%39, %92, %104) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %115
%107 = metatype $@thick AnyObject.Protocol // user: %108
%108 = apply %45<AnyObject>(%107) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %111
%109 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %110
%110 = apply %45<HeapBufferStorage<_ArrayBody, Int>>(%109) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %111
%111 = apply %18(%108, %110) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %113
%112 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %113, %123, %171
%113 = apply %112(%111, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %114
cond_fail %113 : $Builtin.Int1 // id: %114
%115 = unchecked_ref_bit_cast %106 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %116
%116 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %115 : $HeapBufferStorage<_ArrayBody, Int> // users: %117, %125
%117 = struct $HeapBuffer<_ArrayBody, Int> (%116 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %165
%118 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %119
%119 = apply %45<HeapBufferStorage<_ArrayBody, Int>?>(%118) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %122
%120 = metatype $@thick Builtin.NativeObject.Type // user: %121
%121 = apply %45<Builtin.NativeObject>(%120) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %122
%122 = apply %18(%119, %121) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %123
%123 = apply %112(%122, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %124
cond_fail %123 : $Builtin.Int1 // id: %124
%125 = unchecked_ref_bit_cast %116 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %126
%126 = ref_to_raw_pointer %125 : $Builtin.NativeObject to $Builtin.RawPointer // users: %131, %138, %168
%127 = metatype $@thick Int8.Type // user: %128
%128 = apply %16<Int8>(%127) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %129, %166
%129 = apply %83(%66, %128, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %130
%130 = tuple_extract %129 : $(Builtin.Word, Builtin.Int1), 0 // user: %131
%131 = index_raw_pointer %126 : $Builtin.RawPointer, %130 : $Builtin.Word // user: %132
%132 = pointer_to_address %131 : $Builtin.RawPointer to $*_ArrayBody // users: %136, %164
%133 = struct $Int (%9 : $Builtin.Word) // user: %135
%134 = struct $UInt (%9 : $Builtin.Word) // user: %135
%135 = struct $_ArrayBody (%133 : $Int, %134 : $UInt) // user: %136
store %135 to %132 : $*_ArrayBody // id: %136
// function_ref malloc_size
%137 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %139
%138 = struct $UnsafePointer<()> (%126 : $Builtin.RawPointer) // user: %139
%139 = apply %137(%138) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %140
%140 = struct_extract %139 : $UInt, #UInt.value // user: %141
%141 = apply %58(%140, %82, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %142, %143
%142 = tuple_extract %141 : $(Builtin.Word, Builtin.Int1), 0 // users: %145, %148
%143 = tuple_extract %141 : $(Builtin.Word, Builtin.Int1), 1 // user: %144
cond_fail %143 : $Builtin.Int1 // id: %144
%145 = apply %18(%142, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %146
%146 = apply %25(%145, %24) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %147
cond_fail %146 : $Builtin.Int1 // id: %147
%148 = apply %28(%142, %17) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %150
%149 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %150
%150 = apply %149(%148) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %152
%151 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %152
%152 = apply %151(%150) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %153, %154
%153 = tuple_extract %152 : $(Builtin.Int64, Builtin.Int1), 0 // user: %157
%154 = tuple_extract %152 : $(Builtin.Int64, Builtin.Int1), 1 // user: %155
cond_fail %154 : $Builtin.Int1 // id: %155
%156 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %157
%157 = apply %156(%153) : $@thin (Builtin.Int64) -> Builtin.Word // user: %159
%158 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %159
%159 = apply %158(%157, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %161
%160 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %161
%161 = apply %160(%159, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %162
%162 = struct $UInt (%161 : $Builtin.Word) // user: %163
%163 = struct $_ArrayBody (%37 : $Int, %162 : $UInt) // user: %164
store %163 to %132 : $*_ArrayBody // id: %164
%165 = struct $_ContiguousArrayBuffer<Int> (%117 : $HeapBuffer<_ArrayBody, Int>) // user: %175
%166 = apply %83(%82, %128, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %167
%167 = tuple_extract %166 : $(Builtin.Word, Builtin.Int1), 0 // user: %168
%168 = index_raw_pointer %126 : $Builtin.RawPointer, %167 : $Builtin.Word // user: %176
%169 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %170
%170 = apply %169(%9, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %171
%171 = apply %112(%170, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %172
cond_fail %171 : $Builtin.Int1 // id: %172
%173 = apply %18(%9, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %174
cond_br %173, bb8, bb9 // id: %174
bb8: // Preds: bb7 bb10
br bb15(%165 : $_ContiguousArrayBuffer<Int>) // id: %175
bb9: // Preds: bb7
br bb10(%9 : $Builtin.Word, %168 : $Builtin.RawPointer, %9 : $Builtin.Word) // id: %176
bb10(%177 : $Builtin.Word, %178 : $Builtin.RawPointer, %179 : $Builtin.Word): // Preds: bb9 bb10
%180 = apply %51(%177, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %181
%181 = tuple_extract %180 : $(Builtin.Word, Builtin.Int1), 0 // users: %190, %191
%182 = index_raw_pointer %178 : $Builtin.RawPointer, %17 : $Builtin.Word // user: %191
%183 = apply %51(%179, %57, %30) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %184
%184 = tuple_extract %183 : $(Builtin.Word, Builtin.Int1), 0 // user: %191
%185 = pointer_to_address %5 : $Builtin.RawPointer to $*Int // user: %186
%186 = index_addr %185 : $*Int, %179 : $Builtin.Word // user: %187
%187 = load %186 : $*Int // user: %189
%188 = pointer_to_address %178 : $Builtin.RawPointer to $*Int // user: %189
store %187 to %188 : $*Int // id: %189
%190 = apply %18(%181, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %191
cond_br %190, bb8, bb10(%181 : $Builtin.Word, %182 : $Builtin.RawPointer, %184 : $Builtin.Word) // id: %191
bb11: // Preds: bb5
br bb7(%97 : $Int) // id: %192
bb12: // Preds: bb4
%193 = apply %40(%95, %80) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %194
cond_br %193, bb13, bb14 // id: %194
bb13: // Preds: bb12
br bb7(%98 : $Int) // id: %195
bb14: // Preds: bb12
br bb7(%96 : $Int) // id: %196
bb15(%197 : $_ContiguousArrayBuffer<Int>): // Preds: bb1 bb8
return %197 : $_ContiguousArrayBuffer<Int> // id: %198
}
// specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element>
sil shared specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.~> infix <A : Swift.CollectionType>(A, (Swift._CopyToNativeArrayBuffer, ())) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin (@in UnsafeBufferPointer<Int>, _CopyToNativeArrayBuffer) -> @owned _ContiguousArrayBuffer<Int> {
bb0(%0 : $*UnsafeBufferPointer<Int>, %1 : $_CopyToNativeArrayBuffer):
%2 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %3
%3 = struct_element_addr %2 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %4
%4 = load %3 : $*Builtin.RawPointer // users: %12, %184
%5 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %6
%6 = struct_element_addr %5 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %7
%7 = load %6 : $*Builtin.RawPointer // user: %11
%8 = integer_literal $Builtin.Word, 0 // users: %18, %30, %40, %41, %132, %133, %160, %169, %172, %175, %175
%9 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %13
%10 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %11, %12
%11 = apply %10(%7) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%12 = apply %10(%4) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%13 = apply %9(%11, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %21, %28
%14 = metatype $@thick Int.Type // users: %16, %71
%15 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %127
%16 = apply %15<Int>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %18, %23, %28, %83, %147, %181
%17 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %18, %21, %23, %30, %110, %121, %144, %172, %189
%18 = apply %17(%16, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = integer_literal $Builtin.Word, -9223372036854775808 // users: %21, %144
%21 = apply %17(%13, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
%22 = integer_literal $Builtin.Word, -1 // users: %23, %63, %80
%23 = apply %17(%16, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %25, %145
%24 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %25, %145
%25 = apply %24(%21, %23) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %26
cond_fail %25 : $Builtin.Int1 // id: %26
%27 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %28, %147
%28 = apply %27(%13, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %30, %36, %40, %42, %169, %172, %189
%29 = integer_literal $Builtin.Int1, 0 // users: %58, %60, %76, %78, %93, %128, %165, %179, %182
%30 = apply %17(%28, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %31
cond_br %30, bb1, bb2 // id: %31
bb1: // Preds: bb0
%32 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %33
%33 = struct $HeapBuffer<_ArrayBody, Int> (%32 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %34
%34 = struct $_ContiguousArrayBuffer<Int> (%33 : $HeapBuffer<_ArrayBody, Int>) // user: %35
br bb15(%34 : $_ContiguousArrayBuffer<Int>) // id: %35
bb2: // Preds: bb0
%36 = struct $Int (%28 : $Builtin.Word) // user: %162
%37 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %38
%38 = upcast %37 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %105
%39 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %40, %98, %100, %192
%40 = apply %39(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %41
cond_br %40, bb3, bb4(%8 : $Builtin.Word) // id: %41
bb3: // Preds: bb2
br bb4(%28 : $Builtin.Word) // id: %42
bb4(%43 : $Builtin.Word): // Preds: bb2 bb3
%44 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %46, %66, %107, %109, %118, %120
%45 = metatype $@thick HeapObject.Type // users: %46, %92
%46 = apply %44<HeapObject>(%45) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %52
%47 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %49, %71, %92
%48 = metatype $@thick _ArrayBody.Type // users: %49, %66
%49 = apply %47<_ArrayBody>(%48) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %52, %60
%50 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %52, %67, %72, %87, %179, %182
%51 = integer_literal $Builtin.Int1, -1 // users: %52, %67, %72, %83, %87, %112, %122, %140, %170
%52 = apply %50(%46, %49, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %53, %54
%53 = tuple_extract %52 : $(Builtin.Word, Builtin.Int1), 0 // user: %58
%54 = tuple_extract %52 : $(Builtin.Word, Builtin.Int1), 1 // user: %55
cond_fail %54 : $Builtin.Int1 // id: %55
%56 = integer_literal $Builtin.Word, 1 // users: %58, %60, %76, %78, %93, %158, %179, %182
%57 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %58, %60, %76, %78, %93, %140
%58 = apply %57(%53, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %59
%59 = tuple_extract %58 : $(Builtin.Word, Builtin.Int1), 0 // user: %65
%60 = apply %57(%49, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %61
%61 = tuple_extract %60 : $(Builtin.Word, Builtin.Int1), 0 // users: %63, %96, %98, %100
%62 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %63, %80
%63 = apply %62(%61, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %65
%64 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %65, %81
%65 = apply %64(%59, %63) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %67, %128
%66 = apply %44<_ArrayBody>(%48) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %67
%67 = apply %50(%65, %66, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %68, %69
%68 = tuple_extract %67 : $(Builtin.Word, Builtin.Int1), 0 // user: %72
%69 = tuple_extract %67 : $(Builtin.Word, Builtin.Int1), 1 // user: %70
cond_fail %69 : $Builtin.Int1 // id: %70
%71 = apply %47<Int>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %72, %78
%72 = apply %50(%68, %71, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %73, %74
%73 = tuple_extract %72 : $(Builtin.Word, Builtin.Int1), 0 // user: %76
%74 = tuple_extract %72 : $(Builtin.Word, Builtin.Int1), 1 // user: %75
cond_fail %74 : $Builtin.Int1 // id: %75
%76 = apply %57(%73, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %77
%77 = tuple_extract %76 : $(Builtin.Word, Builtin.Int1), 0 // user: %81
%78 = apply %57(%71, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %79
%79 = tuple_extract %78 : $(Builtin.Word, Builtin.Int1), 0 // users: %80, %97, %100, %192
%80 = apply %62(%79, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %81
%81 = apply %64(%77, %80) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %87, %140, %165
%82 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %83, %128, %165
%83 = apply %82(%43, %16, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %84, %85
%84 = tuple_extract %83 : $(Builtin.Word, Builtin.Int1), 0 // user: %87
%85 = tuple_extract %83 : $(Builtin.Word, Builtin.Int1), 1 // user: %86
cond_fail %85 : $Builtin.Int1 // id: %86
%87 = apply %50(%81, %84, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %88, %89
%88 = tuple_extract %87 : $(Builtin.Word, Builtin.Int1), 0 // user: %91
%89 = tuple_extract %87 : $(Builtin.Word, Builtin.Int1), 1 // user: %90
cond_fail %89 : $Builtin.Int1 // id: %90
%91 = struct $Int (%88 : $Builtin.Word) // user: %105
%92 = apply %47<HeapObject>(%45) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %93
%93 = apply %57(%92, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %94
%94 = tuple_extract %93 : $(Builtin.Word, Builtin.Int1), 0 // users: %95, %98, %192
%95 = struct $Int (%94 : $Builtin.Word) // user: %195
%96 = struct $Int (%61 : $Builtin.Word) // user: %191
%97 = struct $Int (%79 : $Builtin.Word) // users: %102, %194
%98 = apply %39(%94, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %99
cond_br %98, bb5, bb12 // id: %99
bb5: // Preds: bb4
%100 = apply %39(%61, %79) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %101
cond_br %100, bb6, bb11 // id: %101
bb6: // Preds: bb5
br bb7(%97 : $Int) // id: %102
bb7(%103 : $Int): // Preds: bb6 bb11 bb13 bb14
// function_ref swift_bufferAllocate
%104 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %105
%105 = apply %104(%38, %91, %103) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %114
%106 = metatype $@thick AnyObject.Protocol // user: %107
%107 = apply %44<AnyObject>(%106) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %110
%108 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %109
%109 = apply %44<HeapBufferStorage<_ArrayBody, Int>>(%108) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %110
%110 = apply %17(%107, %109) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %112
%111 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %112, %122, %170
%112 = apply %111(%110, %51) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %113
cond_fail %112 : $Builtin.Int1 // id: %113
%114 = unchecked_ref_bit_cast %105 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %115
%115 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %114 : $HeapBufferStorage<_ArrayBody, Int> // users: %116, %124
%116 = struct $HeapBuffer<_ArrayBody, Int> (%115 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %164
%117 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %118
%118 = apply %44<HeapBufferStorage<_ArrayBody, Int>?>(%117) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%119 = metatype $@thick Builtin.NativeObject.Type // user: %120
%120 = apply %44<Builtin.NativeObject>(%119) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%121 = apply %17(%118, %120) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %122
%122 = apply %111(%121, %51) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %123
cond_fail %122 : $Builtin.Int1 // id: %123
%124 = unchecked_ref_bit_cast %115 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %125
%125 = ref_to_raw_pointer %124 : $Builtin.NativeObject to $Builtin.RawPointer // users: %130, %137, %167
%126 = metatype $@thick Int8.Type // user: %127
%127 = apply %15<Int8>(%126) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %128, %165
%128 = apply %82(%65, %127, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %129
%129 = tuple_extract %128 : $(Builtin.Word, Builtin.Int1), 0 // user: %130
%130 = index_raw_pointer %125 : $Builtin.RawPointer, %129 : $Builtin.Word // user: %131
%131 = pointer_to_address %130 : $Builtin.RawPointer to $*_ArrayBody // users: %135, %163
%132 = struct $Int (%8 : $Builtin.Word) // user: %134
%133 = struct $UInt (%8 : $Builtin.Word) // user: %134
%134 = struct $_ArrayBody (%132 : $Int, %133 : $UInt) // user: %135
store %134 to %131 : $*_ArrayBody // id: %135
// function_ref malloc_size
%136 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %138
%137 = struct $UnsafePointer<()> (%125 : $Builtin.RawPointer) // user: %138
%138 = apply %136(%137) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %139
%139 = struct_extract %138 : $UInt, #UInt.value // user: %140
%140 = apply %57(%139, %81, %51) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %141, %142
%141 = tuple_extract %140 : $(Builtin.Word, Builtin.Int1), 0 // users: %144, %147
%142 = tuple_extract %140 : $(Builtin.Word, Builtin.Int1), 1 // user: %143
cond_fail %142 : $Builtin.Int1 // id: %143
%144 = apply %17(%141, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %145
%145 = apply %24(%144, %23) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %146
cond_fail %145 : $Builtin.Int1 // id: %146
%147 = apply %27(%141, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %149
%148 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %149
%149 = apply %148(%147) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %151
%150 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %151
%151 = apply %150(%149) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %152, %153
%152 = tuple_extract %151 : $(Builtin.Int64, Builtin.Int1), 0 // user: %156
%153 = tuple_extract %151 : $(Builtin.Int64, Builtin.Int1), 1 // user: %154
cond_fail %153 : $Builtin.Int1 // id: %154
%155 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %156
%156 = apply %155(%152) : $@thin (Builtin.Int64) -> Builtin.Word // user: %158
%157 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %158
%158 = apply %157(%156, %56) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %160
%159 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %160
%160 = apply %159(%158, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %161
%161 = struct $UInt (%160 : $Builtin.Word) // user: %162
%162 = struct $_ArrayBody (%36 : $Int, %161 : $UInt) // user: %163
store %162 to %131 : $*_ArrayBody // id: %163
%164 = struct $_ContiguousArrayBuffer<Int> (%116 : $HeapBuffer<_ArrayBody, Int>) // user: %174
%165 = apply %82(%81, %127, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %166
%166 = tuple_extract %165 : $(Builtin.Word, Builtin.Int1), 0 // user: %167
%167 = index_raw_pointer %125 : $Builtin.RawPointer, %166 : $Builtin.Word // user: %175
%168 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %169
%169 = apply %168(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %170
%170 = apply %111(%169, %51) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %171
cond_fail %170 : $Builtin.Int1 // id: %171
%172 = apply %17(%8, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %173
cond_br %172, bb8, bb9 // id: %173
bb8: // Preds: bb7 bb10
br bb15(%164 : $_ContiguousArrayBuffer<Int>) // id: %174
bb9: // Preds: bb7
br bb10(%8 : $Builtin.Word, %167 : $Builtin.RawPointer, %8 : $Builtin.Word) // id: %175
bb10(%176 : $Builtin.Word, %177 : $Builtin.RawPointer, %178 : $Builtin.Word): // Preds: bb9 bb10
%179 = apply %50(%176, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %180
%180 = tuple_extract %179 : $(Builtin.Word, Builtin.Int1), 0 // users: %189, %190
%181 = index_raw_pointer %177 : $Builtin.RawPointer, %16 : $Builtin.Word // user: %190
%182 = apply %50(%178, %56, %29) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %183
%183 = tuple_extract %182 : $(Builtin.Word, Builtin.Int1), 0 // user: %190
%184 = pointer_to_address %4 : $Builtin.RawPointer to $*Int // user: %185
%185 = index_addr %184 : $*Int, %178 : $Builtin.Word // user: %186
%186 = load %185 : $*Int // user: %188
%187 = pointer_to_address %177 : $Builtin.RawPointer to $*Int // user: %188
store %186 to %187 : $*Int // id: %188
%189 = apply %17(%180, %28) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %190
cond_br %189, bb8, bb10(%180 : $Builtin.Word, %181 : $Builtin.RawPointer, %183 : $Builtin.Word) // id: %190
bb11: // Preds: bb5
br bb7(%96 : $Int) // id: %191
bb12: // Preds: bb4
%192 = apply %39(%94, %79) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %193
cond_br %192, bb13, bb14 // id: %193
bb13: // Preds: bb12
br bb7(%97 : $Int) // id: %194
bb14: // Preds: bb12
br bb7(%95 : $Int) // id: %195
bb15(%196 : $_ContiguousArrayBuffer<Int>): // Preds: bb1 bb8
return %196 : $_ContiguousArrayBuffer<Int> // id: %197
}
// specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element>
sil shared specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift._copyCollectionToNativeArrayBuffer <A : Swift.CollectionType>(A) -> Swift._ContiguousArrayBuffer<A._Element> : $@thin (@in UnsafeBufferPointer<Int>) -> @owned _ContiguousArrayBuffer<Int> {
bb0(%0 : $*UnsafeBufferPointer<Int>):
%1 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %2
%2 = struct_element_addr %1 : $*UnsafePointer<Int>, #UnsafePointer.value // users: %3, %190
%3 = load %2 : $*Builtin.RawPointer // user: %11
%4 = struct_element_addr %0 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %5
%5 = struct_element_addr %4 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %6
%6 = load %5 : $*Builtin.RawPointer // user: %10
%7 = integer_literal $Builtin.Word, 0 // users: %17, %29, %41, %42, %133, %134, %161, %170, %173, %181, %181
%8 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %12
%9 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %10, %11
%10 = apply %9(%6) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %12
%11 = apply %9(%3) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %12
%12 = apply %8(%10, %11) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %20, %27
%13 = metatype $@thick Int.Type // users: %15, %72
%14 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %15, %128
%15 = apply %14<Int>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %17, %22, %27, %84, %148, %187
%16 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %17, %20, %22, %29, %111, %122, %145, %173, %196
%17 = apply %16(%15, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
%19 = integer_literal $Builtin.Word, -9223372036854775808 // users: %20, %145
%20 = apply %16(%12, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
%21 = integer_literal $Builtin.Word, -1 // users: %22, %64, %81
%22 = apply %16(%15, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %24, %146
%23 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %24, %146
%24 = apply %23(%20, %22) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %25
cond_fail %24 : $Builtin.Int1 // id: %25
%26 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %27, %148
%27 = apply %26(%12, %15) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %29, %37, %41, %43, %170, %173, %196
%28 = integer_literal $Builtin.Int1, 0 // users: %59, %61, %77, %79, %94, %129, %166, %185, %188
%29 = apply %16(%27, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %30
cond_br %29, bb1, bb3 // id: %30
bb1: // Preds: bb0
%31 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %32
%32 = struct $HeapBuffer<_ArrayBody, Int> (%31 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %33
%33 = struct $_ContiguousArrayBuffer<Int> (%32 : $HeapBuffer<_ArrayBody, Int>) // user: %34
br bb2(%33 : $_ContiguousArrayBuffer<Int>) // id: %34
bb2(%35 : $_ContiguousArrayBuffer<Int>): // Preds: bb1 bb13
return %35 : $_ContiguousArrayBuffer<Int> // id: %36
bb3: // Preds: bb0
%37 = struct $Int (%27 : $Builtin.Word) // user: %163
%38 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %39
%39 = upcast %38 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %106
%40 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %41, %99, %101, %176
%41 = apply %40(%7, %27) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %42
cond_br %41, bb4, bb5(%7 : $Builtin.Word) // id: %42
bb4: // Preds: bb3
br bb5(%27 : $Builtin.Word) // id: %43
bb5(%44 : $Builtin.Word): // Preds: bb3 bb4
%45 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %47, %67, %108, %110, %119, %121
%46 = metatype $@thick HeapObject.Type // users: %47, %93
%47 = apply %45<HeapObject>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %53
%48 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %50, %72, %93
%49 = metatype $@thick _ArrayBody.Type // users: %50, %67
%50 = apply %48<_ArrayBody>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %53, %61
%51 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %53, %68, %73, %88, %185, %188
%52 = integer_literal $Builtin.Int1, -1 // users: %53, %68, %73, %84, %88, %113, %123, %141, %171
%53 = apply %51(%47, %50, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %54, %55
%54 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 0 // user: %59
%55 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 1 // user: %56
cond_fail %55 : $Builtin.Int1 // id: %56
%57 = integer_literal $Builtin.Word, 1 // users: %59, %61, %77, %79, %94, %159, %185, %188
%58 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %59, %61, %77, %79, %94, %141
%59 = apply %58(%54, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %60
%60 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%61 = apply %58(%50, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %62
%62 = tuple_extract %61 : $(Builtin.Word, Builtin.Int1), 0 // users: %64, %97, %99, %101
%63 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %64, %81
%64 = apply %63(%62, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %66
%65 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %66, %82
%66 = apply %65(%60, %64) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %68, %129
%67 = apply %45<_ArrayBody>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %68
%68 = apply %51(%66, %67, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %69, %70
%69 = tuple_extract %68 : $(Builtin.Word, Builtin.Int1), 0 // user: %73
%70 = tuple_extract %68 : $(Builtin.Word, Builtin.Int1), 1 // user: %71
cond_fail %70 : $Builtin.Int1 // id: %71
%72 = apply %48<Int>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %73, %79
%73 = apply %51(%69, %72, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %74, %75
%74 = tuple_extract %73 : $(Builtin.Word, Builtin.Int1), 0 // user: %77
%75 = tuple_extract %73 : $(Builtin.Word, Builtin.Int1), 1 // user: %76
cond_fail %75 : $Builtin.Int1 // id: %76
%77 = apply %58(%74, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %78
%78 = tuple_extract %77 : $(Builtin.Word, Builtin.Int1), 0 // user: %82
%79 = apply %58(%72, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %80
%80 = tuple_extract %79 : $(Builtin.Word, Builtin.Int1), 0 // users: %81, %98, %101, %176
%81 = apply %63(%80, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %82
%82 = apply %65(%78, %81) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %88, %141, %166
%83 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %84, %129, %166
%84 = apply %83(%44, %15, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %85, %86
%85 = tuple_extract %84 : $(Builtin.Word, Builtin.Int1), 0 // user: %88
%86 = tuple_extract %84 : $(Builtin.Word, Builtin.Int1), 1 // user: %87
cond_fail %86 : $Builtin.Int1 // id: %87
%88 = apply %51(%82, %85, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %89, %90
%89 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 0 // user: %92
%90 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 1 // user: %91
cond_fail %90 : $Builtin.Int1 // id: %91
%92 = struct $Int (%89 : $Builtin.Word) // user: %106
%93 = apply %48<HeapObject>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %94
%94 = apply %58(%93, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %95
%95 = tuple_extract %94 : $(Builtin.Word, Builtin.Int1), 0 // users: %96, %99, %176
%96 = struct $Int (%95 : $Builtin.Word) // user: %179
%97 = struct $Int (%62 : $Builtin.Word) // user: %175
%98 = struct $Int (%80 : $Builtin.Word) // users: %103, %178
%99 = apply %40(%95, %62) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %100
cond_br %99, bb6, bb10 // id: %100
bb6: // Preds: bb5
%101 = apply %40(%62, %80) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %102
cond_br %101, bb7, bb9 // id: %102
bb7: // Preds: bb6
br bb8(%98 : $Int) // id: %103
bb8(%104 : $Int): // Preds: bb7 bb9 bb11 bb12
// function_ref swift_bufferAllocate
%105 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %106
%106 = apply %105(%39, %92, %104) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %115
%107 = metatype $@thick AnyObject.Protocol // user: %108
%108 = apply %45<AnyObject>(%107) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %111
%109 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %110
%110 = apply %45<HeapBufferStorage<_ArrayBody, Int>>(%109) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %111
%111 = apply %16(%108, %110) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %113
%112 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %113, %123, %171
%113 = apply %112(%111, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %114
cond_fail %113 : $Builtin.Int1 // id: %114
%115 = unchecked_ref_bit_cast %106 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %116
%116 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %115 : $HeapBufferStorage<_ArrayBody, Int> // users: %117, %125
%117 = struct $HeapBuffer<_ArrayBody, Int> (%116 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %165
%118 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %119
%119 = apply %45<HeapBufferStorage<_ArrayBody, Int>?>(%118) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %122
%120 = metatype $@thick Builtin.NativeObject.Type // user: %121
%121 = apply %45<Builtin.NativeObject>(%120) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %122
%122 = apply %16(%119, %121) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %123
%123 = apply %112(%122, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %124
cond_fail %123 : $Builtin.Int1 // id: %124
%125 = unchecked_ref_bit_cast %116 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %126
%126 = ref_to_raw_pointer %125 : $Builtin.NativeObject to $Builtin.RawPointer // users: %131, %138, %168
%127 = metatype $@thick Int8.Type // user: %128
%128 = apply %14<Int8>(%127) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %129, %166
%129 = apply %83(%66, %128, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %130
%130 = tuple_extract %129 : $(Builtin.Word, Builtin.Int1), 0 // user: %131
%131 = index_raw_pointer %126 : $Builtin.RawPointer, %130 : $Builtin.Word // user: %132
%132 = pointer_to_address %131 : $Builtin.RawPointer to $*_ArrayBody // users: %136, %164
%133 = struct $Int (%7 : $Builtin.Word) // user: %135
%134 = struct $UInt (%7 : $Builtin.Word) // user: %135
%135 = struct $_ArrayBody (%133 : $Int, %134 : $UInt) // user: %136
store %135 to %132 : $*_ArrayBody // id: %136
// function_ref malloc_size
%137 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %139
%138 = struct $UnsafePointer<()> (%126 : $Builtin.RawPointer) // user: %139
%139 = apply %137(%138) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %140
%140 = struct_extract %139 : $UInt, #UInt.value // user: %141
%141 = apply %58(%140, %82, %52) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %142, %143
%142 = tuple_extract %141 : $(Builtin.Word, Builtin.Int1), 0 // users: %145, %148
%143 = tuple_extract %141 : $(Builtin.Word, Builtin.Int1), 1 // user: %144
cond_fail %143 : $Builtin.Int1 // id: %144
%145 = apply %16(%142, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %146
%146 = apply %23(%145, %22) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %147
cond_fail %146 : $Builtin.Int1 // id: %147
%148 = apply %26(%142, %15) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %150
%149 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %150
%150 = apply %149(%148) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %152
%151 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %152
%152 = apply %151(%150) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %153, %154
%153 = tuple_extract %152 : $(Builtin.Int64, Builtin.Int1), 0 // user: %157
%154 = tuple_extract %152 : $(Builtin.Int64, Builtin.Int1), 1 // user: %155
cond_fail %154 : $Builtin.Int1 // id: %155
%156 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %157
%157 = apply %156(%153) : $@thin (Builtin.Int64) -> Builtin.Word // user: %159
%158 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %159
%159 = apply %158(%157, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %161
%160 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %161
%161 = apply %160(%159, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %162
%162 = struct $UInt (%161 : $Builtin.Word) // user: %163
%163 = struct $_ArrayBody (%37 : $Int, %162 : $UInt) // user: %164
store %163 to %132 : $*_ArrayBody // id: %164
%165 = struct $_ContiguousArrayBuffer<Int> (%117 : $HeapBuffer<_ArrayBody, Int>) // user: %180
%166 = apply %83(%82, %128, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %167
%167 = tuple_extract %166 : $(Builtin.Word, Builtin.Int1), 0 // user: %168
%168 = index_raw_pointer %126 : $Builtin.RawPointer, %167 : $Builtin.Word // user: %181
%169 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %170
%170 = apply %169(%7, %27) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %171
%171 = apply %112(%170, %52) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %172
cond_fail %171 : $Builtin.Int1 // id: %172
%173 = apply %16(%7, %27) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %174
cond_br %173, bb13, bb14 // id: %174
bb9: // Preds: bb6
br bb8(%97 : $Int) // id: %175
bb10: // Preds: bb5
%176 = apply %40(%95, %80) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %177
cond_br %176, bb11, bb12 // id: %177
bb11: // Preds: bb10
br bb8(%98 : $Int) // id: %178
bb12: // Preds: bb10
br bb8(%96 : $Int) // id: %179
bb13: // Preds: bb8 bb15
br bb2(%165 : $_ContiguousArrayBuffer<Int>) // id: %180
bb14: // Preds: bb8
br bb15(%7 : $Builtin.Word, %168 : $Builtin.RawPointer, %7 : $Builtin.Word) // id: %181
bb15(%182 : $Builtin.Word, %183 : $Builtin.RawPointer, %184 : $Builtin.Word): // Preds: bb14 bb15
%185 = apply %51(%182, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %186
%186 = tuple_extract %185 : $(Builtin.Word, Builtin.Int1), 0 // users: %196, %197
%187 = index_raw_pointer %183 : $Builtin.RawPointer, %15 : $Builtin.Word // user: %197
%188 = apply %51(%184, %57, %28) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %189
%189 = tuple_extract %188 : $(Builtin.Word, Builtin.Int1), 0 // user: %197
%190 = load %2 : $*Builtin.RawPointer // user: %191
%191 = pointer_to_address %190 : $Builtin.RawPointer to $*Int // user: %192
%192 = index_addr %191 : $*Int, %184 : $Builtin.Word // user: %193
%193 = load %192 : $*Int // user: %195
%194 = pointer_to_address %183 : $Builtin.RawPointer to $*Int // user: %195
store %193 to %194 : $*Int // id: %195
%196 = apply %16(%186, %27) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %197
cond_br %196, bb13, bb15(%186 : $Builtin.Word, %187 : $Builtin.RawPointer, %189 : $Builtin.Word) // id: %197
}
// specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance
sil shared specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.countElements <A : Swift._CollectionType>(A) -> A.Index.Distance : $@thin (@out Int, @in UnsafeBufferPointer<Int>) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<Int>):
%2 = struct_element_addr %1 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %3
%3 = struct_element_addr %2 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %4
%4 = load %3 : $*Builtin.RawPointer // user: %12
%5 = struct_element_addr %1 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %6
%6 = struct_element_addr %5 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %7
%7 = load %6 : $*Builtin.RawPointer // user: %11
%8 = integer_literal $Builtin.Word, 0 // user: %18
%9 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %13
%10 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %11, %12
%11 = apply %10(%7) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%12 = apply %10(%4) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %13
%13 = apply %9(%11, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %21, %28
%14 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%15 = metatype $@thick Int.Type // user: %16
%16 = apply %14<Int>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %18, %23, %28
%17 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %18, %21, %23
%18 = apply %17(%16, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = integer_literal $Builtin.Word, -9223372036854775808 // user: %21
%21 = apply %17(%13, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
%22 = integer_literal $Builtin.Word, -1 // user: %23
%23 = apply %17(%16, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %25
%24 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %25
%25 = apply %24(%21, %23) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %26
cond_fail %25 : $Builtin.Int1 // id: %26
%27 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %28
%28 = apply %27(%13, %16) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %29
%29 = struct $Int (%28 : $Builtin.Word) // user: %30
store %29 to %0 : $*Int // id: %30
%31 = tuple () // user: %32
return %31 : $() // id: %32
}
// specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
sil shared specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin (@out Int, @in UnsafeBufferPointer<Int>, _CountElements) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<Int>, %2 : $_CountElements):
%3 = integer_literal $Builtin.Word, 0 // user: %19
%4 = struct_element_addr %1 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._position // user: %5
%5 = struct_element_addr %4 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %6
%6 = load %5 : $*Builtin.RawPointer // user: %13
%7 = struct_element_addr %1 : $*UnsafeBufferPointer<Int>, #UnsafeBufferPointer._end // user: %8
%8 = struct_element_addr %7 : $*UnsafePointer<Int>, #UnsafePointer.value // user: %9
%9 = load %8 : $*Builtin.RawPointer // user: %12
%10 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %14
%11 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %12, %13
%12 = apply %11(%9) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %14
%13 = apply %11(%6) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %14
%14 = apply %10(%12, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %22, %29
%15 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %17
%16 = metatype $@thick Int.Type // user: %17
%17 = apply %15<Int>(%16) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %19, %24, %29
%18 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %19, %22, %24
%19 = apply %18(%17, %3) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %20
cond_fail %19 : $Builtin.Int1 // id: %20
%21 = integer_literal $Builtin.Word, -9223372036854775808 // user: %22
%22 = apply %18(%14, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %26
%23 = integer_literal $Builtin.Word, -1 // user: %24
%24 = apply %18(%17, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %26
%25 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %26
%26 = apply %25(%22, %24) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %27
cond_fail %26 : $Builtin.Int1 // id: %27
%28 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %29
%29 = apply %28(%14, %17) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %30
%30 = struct $Int (%29 : $Builtin.Word) // user: %31
store %30 to %0 : $*Int // id: %31
%32 = tuple () // user: %33
return %32 : $() // id: %33
}
// protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.UnsafeBufferPointer : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.UnsafeBufferPointer : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>.Index, @inout UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<T>):
%2 = load %1 : $*UnsafeBufferPointer<T> // user: %4
// function_ref Swift.UnsafeBufferPointer.startIndex.getter : Swift.Int
%3 = function_ref Swift.UnsafeBufferPointer.startIndex.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> Int // user: %4
%4 = apply %3<T>(%2) : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> Int // user: %5
store %4 to %0 : $*Int // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.UnsafeBufferPointer : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.UnsafeBufferPointer : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>.Index, @inout UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<T>):
%2 = load %1 : $*UnsafeBufferPointer<T> // user: %4
// function_ref Swift.UnsafeBufferPointer.endIndex.getter : Swift.Int
%3 = function_ref Swift.UnsafeBufferPointer.endIndex.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> Int // user: %4
%4 = apply %3<T>(%2) : $@cc(method) @thin <τ_0_0> (UnsafeBufferPointer<τ_0_0>) -> Int // user: %5
store %4 to %0 : $*Int // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.UnsafeBufferPointer : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.UnsafeBufferPointer : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>._Element, @in UnsafeBufferPointer<T>.Index, @inout UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*T, %1 : $*Int, %2 : $*UnsafeBufferPointer<T>):
%3 = load %2 : $*UnsafeBufferPointer<T> // user: %6
%4 = load %1 : $*Int // user: %6
// function_ref Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A
%5 = function_ref Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeBufferPointer<τ_0_0>) -> () // user: %6
%6 = apply %5<T>(%0, %4, %3) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeBufferPointer<τ_0_0>) -> () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance
sil shared specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.distance <A : Swift.ForwardIndexType>(A, A) -> A.Distance : $@thin (@out Int, @in Int, @in Int) -> () {
bb0(%0 : $*Int, %1 : $*Int, %2 : $*Int):
%3 = struct_element_addr %1 : $*Int, #Int.value // user: %4
%4 = load %3 : $*Builtin.Word // user: %9
%5 = struct_element_addr %2 : $*Int, #Int.value // user: %6
%6 = load %5 : $*Builtin.Word // user: %8
%7 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // users: %8, %9
%8 = apply %7(%6) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %12
%9 = apply %7(%4) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %12
%10 = builtin_function_ref "ssub_with_overflow_Int64" : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %12
%11 = integer_literal $Builtin.Int1, 0 // user: %12
%12 = apply %10(%8, %9, %11) : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %13
%13 = tuple_extract %12 : $(Builtin.Int64, Builtin.Int1), 0 // user: %15
%14 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %15
%15 = apply %14(%13) : $@thin (Builtin.Int64) -> Builtin.Word // user: %16
%16 = struct $Int (%15 : $Builtin.Word) // user: %17
store %16 to %0 : $*Int // id: %17
%18 = tuple () // user: %19
return %18 : $() // id: %19
}
// specialization <Swift.Int> of Swift._distanceTo <A>(A) -> (Swift._Distance, A)
sil shared specialization <Swift.Int> of Swift._distanceTo <A>(A) -> (Swift._Distance, A) : $@thin (@out (_Distance, Int), @in Int) -> () {
bb0(%0 : $*(_Distance, Int), %1 : $*Int):
%2 = tuple_element_addr %0 : $*(_Distance, Int), 0 // user: %5
%3 = tuple_element_addr %0 : $*(_Distance, Int), 1 // user: %7
%4 = struct $_Distance () // user: %5
store %4 to %2 : $*_Distance // id: %5
%6 = load %1 : $*Int // user: %7
store %6 to %3 : $*Int // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// specialization <Swift.Int> of Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A>
sil shared specialization <Swift.Int> of Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A> : $@thin (@thin _ContiguousArrayBuffer<Int>.Type) -> @owned _ContiguousArrayBuffer<Int> {
bb0(%0 : $@thin _ContiguousArrayBuffer<Int>.Type):
%1 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %2
%2 = struct $HeapBuffer<_ArrayBody, Int> (%1 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %3
%3 = struct $_ContiguousArrayBuffer<Int> (%2 : $HeapBuffer<_ArrayBody, Int>) // user: %4
return %3 : $_ContiguousArrayBuffer<Int> // id: %4
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B>
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.HeapBuffer<A, B> : $@thin (@thin HeapBuffer<_ArrayBody, Int>.Type) -> @owned HeapBuffer<_ArrayBody, Int> {
bb0(%0 : $@thin HeapBuffer<_ArrayBody, Int>.Type):
%1 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %2
%2 = struct $HeapBuffer<_ArrayBody, Int> (%1 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %3
return %2 : $HeapBuffer<_ArrayBody, Int> // id: %3
}
// specialization <Swift.Int> of Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A>
sil shared specialization <Swift.Int> of Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(count : Swift.Int, minimumCapacity : Swift.Int) -> Swift._ContiguousArrayBuffer<A> : $@thin (Int, Int, @thin _ContiguousArrayBuffer<Int>.Type) -> @owned _ContiguousArrayBuffer<Int> {
bb0(%0 : $Int, %1 : $Int, %2 : $@thin _ContiguousArrayBuffer<Int>.Type):
%3 = metatype $@thick _ContiguousArrayStorage<Int>.Type // user: %4
%4 = upcast %3 : $@thick _ContiguousArrayStorage<Int>.Type to $@thick AnyObject.Type // user: %79
%5 = integer_literal $Builtin.Word, 0 // users: %107, %108, %119, %141
%6 = struct_extract %0 : $Int, #Int.value // users: %9, %11
%7 = struct_extract %1 : $Int, #Int.value // users: %9, %10
%8 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %9, %72, %74, %148
%9 = apply %8(%7, %6) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %10
cond_br %9, bb1, bb2(%7 : $Builtin.Word) // id: %10
bb1: // Preds: bb0
br bb2(%6 : $Builtin.Word) // id: %11
bb2(%12 : $Builtin.Word): // Preds: bb0 bb1
%13 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %15, %37, %81, %83, %93, %95
%14 = metatype $@thick HeapObject.Type // users: %15, %66
%15 = apply %13<HeapObject>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%16 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %18, %43, %66
%17 = metatype $@thick _ArrayBody.Type // users: %18, %37
%18 = apply %16<_ArrayBody>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %21, %30
%19 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %21, %38, %44, %61
%20 = integer_literal $Builtin.Int1, -1 // users: %21, %38, %44, %57, %61, %87, %97, %115
%21 = apply %19(%15, %18, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %22, %23
%22 = tuple_extract %21 : $(Builtin.Word, Builtin.Int1), 0 // user: %28
%23 = tuple_extract %21 : $(Builtin.Word, Builtin.Int1), 1 // user: %24
cond_fail %23 : $Builtin.Int1 // id: %24
%25 = integer_literal $Builtin.Word, 1 // users: %28, %30, %48, %50, %67, %139
%26 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %28, %30, %48, %50, %67, %115
%27 = integer_literal $Builtin.Int1, 0 // users: %28, %30, %48, %50, %67, %103
%28 = apply %26(%22, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %29
%29 = tuple_extract %28 : $(Builtin.Word, Builtin.Int1), 0 // user: %36
%30 = apply %26(%18, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %31
%31 = tuple_extract %30 : $(Builtin.Word, Builtin.Int1), 0 // users: %34, %70, %72, %74
%32 = integer_literal $Builtin.Word, -1 // users: %34, %52, %123
%33 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %34, %52
%34 = apply %33(%31, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %36
%35 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %36, %53
%36 = apply %35(%29, %34) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %38, %103
%37 = apply %13<_ArrayBody>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %38
%38 = apply %19(%36, %37, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %39, %40
%39 = tuple_extract %38 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%40 = tuple_extract %38 : $(Builtin.Word, Builtin.Int1), 1 // user: %41
cond_fail %40 : $Builtin.Int1 // id: %41
%42 = metatype $@thick Int.Type // users: %43, %55
%43 = apply %16<Int>(%42) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %44, %50
%44 = apply %19(%39, %43, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %45, %46
%45 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%46 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 1 // user: %47
cond_fail %46 : $Builtin.Int1 // id: %47
%48 = apply %26(%45, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %49
%49 = tuple_extract %48 : $(Builtin.Word, Builtin.Int1), 0 // user: %53
%50 = apply %26(%43, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %51
%51 = tuple_extract %50 : $(Builtin.Word, Builtin.Int1), 0 // users: %52, %71, %74, %148
%52 = apply %33(%51, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %53
%53 = apply %35(%49, %52) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %61, %115
%54 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %55, %102
%55 = apply %54<Int>(%42) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %57, %119, %123, %128
%56 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %57, %103
%57 = apply %56(%12, %55, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %58, %59
%58 = tuple_extract %57 : $(Builtin.Word, Builtin.Int1), 0 // user: %61
%59 = tuple_extract %57 : $(Builtin.Word, Builtin.Int1), 1 // user: %60
cond_fail %59 : $Builtin.Int1 // id: %60
%61 = apply %19(%53, %58, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %62, %63
%62 = tuple_extract %61 : $(Builtin.Word, Builtin.Int1), 0 // user: %65
%63 = tuple_extract %61 : $(Builtin.Word, Builtin.Int1), 1 // user: %64
cond_fail %63 : $Builtin.Int1 // id: %64
%65 = struct $Int (%62 : $Builtin.Word) // user: %79
%66 = apply %16<HeapObject>(%14) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %67
%67 = apply %26(%66, %25, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %68
%68 = tuple_extract %67 : $(Builtin.Word, Builtin.Int1), 0 // users: %69, %72, %148
%69 = struct $Int (%68 : $Builtin.Word) // user: %151
%70 = struct $Int (%31 : $Builtin.Word) // user: %147
%71 = struct $Int (%51 : $Builtin.Word) // users: %76, %150
%72 = apply %8(%68, %31) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %73
cond_br %72, bb3, bb7 // id: %73
bb3: // Preds: bb2
%74 = apply %8(%31, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %75
cond_br %74, bb4, bb6 // id: %75
bb4: // Preds: bb3
br bb5(%71 : $Int) // id: %76
bb5(%77 : $Int): // Preds: bb4 bb6 bb8 bb9
// function_ref swift_bufferAllocate
%78 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %79
%79 = apply %78(%4, %65, %77) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %89
%80 = metatype $@thick AnyObject.Protocol // user: %81
%81 = apply %13<AnyObject>(%80) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %85
%82 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %83
%83 = apply %13<HeapBufferStorage<_ArrayBody, Int>>(%82) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %85
%84 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %85, %96, %119, %122, %123
%85 = apply %84(%81, %83) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %87
%86 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %87, %97
%87 = apply %86(%85, %20) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %88
cond_fail %87 : $Builtin.Int1 // id: %88
%89 = unchecked_ref_bit_cast %79 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %90
%90 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %89 : $HeapBufferStorage<_ArrayBody, Int> // users: %91, %99
%91 = struct $HeapBuffer<_ArrayBody, Int> (%90 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %145
%92 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %93
%93 = apply %13<HeapBufferStorage<_ArrayBody, Int>?>(%92) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %96
%94 = metatype $@thick Builtin.NativeObject.Type // user: %95
%95 = apply %13<Builtin.NativeObject>(%94) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %96
%96 = apply %84(%93, %95) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
%97 = apply %86(%96, %20) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = unchecked_ref_bit_cast %90 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %100
%100 = ref_to_raw_pointer %99 : $Builtin.NativeObject to $Builtin.RawPointer // users: %105, %112
%101 = metatype $@thick Int8.Type // user: %102
%102 = apply %54<Int8>(%101) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %103
%103 = apply %56(%36, %102, %27) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %104
%104 = tuple_extract %103 : $(Builtin.Word, Builtin.Int1), 0 // user: %105
%105 = index_raw_pointer %100 : $Builtin.RawPointer, %104 : $Builtin.Word // user: %106
%106 = pointer_to_address %105 : $Builtin.RawPointer to $*_ArrayBody // users: %110, %144
%107 = struct $Int (%5 : $Builtin.Word) // user: %109
%108 = struct $UInt (%5 : $Builtin.Word) // user: %109
%109 = struct $_ArrayBody (%107 : $Int, %108 : $UInt) // user: %110
store %109 to %106 : $*_ArrayBody // id: %110
// function_ref malloc_size
%111 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %113
%112 = struct $UnsafePointer<()> (%100 : $Builtin.RawPointer) // user: %113
%113 = apply %111(%112) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %114
%114 = struct_extract %113 : $UInt, #UInt.value // user: %115
%115 = apply %26(%114, %53, %20) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %116, %117
%116 = tuple_extract %115 : $(Builtin.Word, Builtin.Int1), 0 // users: %122, %128
%117 = tuple_extract %115 : $(Builtin.Word, Builtin.Int1), 1 // user: %118
cond_fail %117 : $Builtin.Int1 // id: %118
%119 = apply %84(%55, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %120
cond_fail %119 : $Builtin.Int1 // id: %120
%121 = integer_literal $Builtin.Word, -9223372036854775808 // user: %122
%122 = apply %84(%116, %121) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %125
%123 = apply %84(%55, %32) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %125
%124 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %125
%125 = apply %124(%122, %123) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %126
cond_fail %125 : $Builtin.Int1 // id: %126
%127 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %128
%128 = apply %127(%116, %55) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %130
%129 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %130
%130 = apply %129(%128) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %132
%131 = builtin_function_ref "s_to_u_checked_conversion_Int64" : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // user: %132
%132 = apply %131(%130) : $@thin (Builtin.Int64) -> (Builtin.Int64, Builtin.Int1) // users: %133, %134
%133 = tuple_extract %132 : $(Builtin.Int64, Builtin.Int1), 0 // user: %137
%134 = tuple_extract %132 : $(Builtin.Int64, Builtin.Int1), 1 // user: %135
cond_fail %134 : $Builtin.Int1 // id: %135
%136 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %137
%137 = apply %136(%133) : $@thin (Builtin.Int64) -> Builtin.Word // user: %139
%138 = builtin_function_ref "shl_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %139
%139 = apply %138(%137, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %141
%140 = builtin_function_ref "or_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %141
%141 = apply %140(%139, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %142
%142 = struct $UInt (%141 : $Builtin.Word) // user: %143
%143 = struct $_ArrayBody (%0 : $Int, %142 : $UInt) // user: %144
store %143 to %106 : $*_ArrayBody // id: %144
%145 = struct $_ContiguousArrayBuffer<Int> (%91 : $HeapBuffer<_ArrayBody, Int>) // user: %146
return %145 : $_ContiguousArrayBuffer<Int> // id: %146
bb6: // Preds: bb3
br bb5(%70 : $Int) // id: %147
bb7: // Preds: bb2
%148 = apply %8(%68, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %149
cond_br %148, bb8, bb9 // id: %149
bb8: // Preds: bb7
br bb5(%71 : $Int) // id: %150
bb9: // Preds: bb7
br bb5(%69 : $Int) // id: %151
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B>
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.init <A, B>(Swift.HeapBuffer<A, B>.Type)(Swift.AnyObject.Type, A, Swift.Int) -> Swift.HeapBuffer<A, B> : $@thin (@thick AnyObject.Type, @in _ArrayBody, Int, @thin HeapBuffer<_ArrayBody, Int>.Type) -> @owned HeapBuffer<_ArrayBody, Int> {
bb0(%0 : $@thick AnyObject.Type, %1 : $*_ArrayBody, %2 : $Int, %3 : $@thin HeapBuffer<_ArrayBody, Int>.Type):
%4 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %28, %79, %81, %91, %93
%5 = metatype $@thick HeapObject.Type // users: %6, %58
%6 = apply %4<HeapObject>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%7 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %9, %34, %58
%8 = metatype $@thick _ArrayBody.Type // users: %9, %28
%9 = apply %7<_ArrayBody>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %12, %21
%10 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %12, %29, %35, %53
%11 = integer_literal $Builtin.Int1, -1 // users: %12, %29, %35, %49, %53, %85, %95
%12 = apply %10(%6, %9, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %13, %14
%13 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 0 // user: %19
%14 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 1 // user: %15
cond_fail %14 : $Builtin.Int1 // id: %15
%16 = integer_literal $Builtin.Word, 1 // users: %19, %21, %39, %41, %59
%17 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %19, %21, %39, %41, %59
%18 = integer_literal $Builtin.Int1, 0 // users: %19, %21, %39, %41, %59, %101
%19 = apply %17(%13, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %20
%20 = tuple_extract %19 : $(Builtin.Word, Builtin.Int1), 0 // user: %27
%21 = apply %17(%9, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %22
%22 = tuple_extract %21 : $(Builtin.Word, Builtin.Int1), 0 // users: %25, %62, %65, %67
%23 = integer_literal $Builtin.Word, -1 // users: %25, %43
%24 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %25, %43
%25 = apply %24(%22, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %27
%26 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %27, %44
%27 = apply %26(%20, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %29, %101
%28 = apply %4<_ArrayBody>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %29
%29 = apply %10(%27, %28, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %30, %31
%30 = tuple_extract %29 : $(Builtin.Word, Builtin.Int1), 0 // user: %35
%31 = tuple_extract %29 : $(Builtin.Word, Builtin.Int1), 1 // user: %32
cond_fail %31 : $Builtin.Int1 // id: %32
%33 = metatype $@thick Int.Type // users: %34, %46
%34 = apply %7<Int>(%33) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %41
%35 = apply %10(%30, %34, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %36, %37
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %39
%37 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = apply %17(%36, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %40
%40 = tuple_extract %39 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%41 = apply %17(%34, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %42
%42 = tuple_extract %41 : $(Builtin.Word, Builtin.Int1), 0 // users: %43, %63, %67, %71
%43 = apply %24(%42, %23) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %44
%44 = apply %26(%40, %43) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %53
%45 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %46, %100
%46 = apply %45<Int>(%33) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %49
%47 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %49, %101
%48 = struct_extract %2 : $Int, #Int.value // user: %49
%49 = apply %47(%48, %46, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %50, %51
%50 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 0 // user: %53
%51 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 1 // user: %52
cond_fail %51 : $Builtin.Int1 // id: %52
%53 = apply %10(%44, %50, %11) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %54, %55
%54 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 0 // user: %57
%55 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 1 // user: %56
cond_fail %55 : $Builtin.Int1 // id: %56
%57 = struct $Int (%54 : $Builtin.Word) // user: %77
%58 = apply %7<HeapObject>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %59
%59 = apply %17(%58, %16, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %60
%60 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 0 // users: %61, %65, %71
%61 = struct $Int (%60 : $Builtin.Word) // user: %74
%62 = struct $Int (%22 : $Builtin.Word) // user: %70
%63 = struct $Int (%42 : $Builtin.Word) // users: %69, %73
%64 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %65, %67, %71
%65 = apply %64(%60, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %66
cond_br %65, bb1, bb4 // id: %66
bb1: // Preds: bb0
%67 = apply %64(%22, %42) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %68
cond_br %67, bb2, bb3 // id: %68
bb2: // Preds: bb1
br bb7(%63 : $Int) // id: %69
bb3: // Preds: bb1
br bb7(%62 : $Int) // id: %70
bb4: // Preds: bb0
%71 = apply %64(%60, %42) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
cond_br %71, bb5, bb6 // id: %72
bb5: // Preds: bb4
br bb7(%63 : $Int) // id: %73
bb6: // Preds: bb4
br bb7(%61 : $Int) // id: %74
bb7(%75 : $Int): // Preds: bb2 bb3 bb5 bb6
// function_ref swift_bufferAllocate
%76 = function_ref @swift_bufferAllocate : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %77
%77 = apply %76(%0, %57, %75) : $@thin (@thick AnyObject.Type, Int, Int) -> @owned AnyObject // user: %87
%78 = metatype $@thick AnyObject.Protocol // user: %79
%79 = apply %4<AnyObject>(%78) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %83
%80 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %81
%81 = apply %4<HeapBufferStorage<_ArrayBody, Int>>(%80) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %83
%82 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %83, %94
%83 = apply %82(%79, %81) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %85
%84 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %85, %95
%85 = apply %84(%83, %11) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %86
cond_fail %85 : $Builtin.Int1 // id: %86
%87 = unchecked_ref_bit_cast %77 : $AnyObject to $HeapBufferStorage<_ArrayBody, Int> // user: %88
%88 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1, %87 : $HeapBufferStorage<_ArrayBody, Int> // users: %89, %97
%89 = struct $HeapBuffer<_ArrayBody, Int> (%88 : $Optional<HeapBufferStorage<_ArrayBody, Int>>) // user: %107
%90 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %91
%91 = apply %4<HeapBufferStorage<_ArrayBody, Int>?>(%90) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %94
%92 = metatype $@thick Builtin.NativeObject.Type // user: %93
%93 = apply %4<Builtin.NativeObject>(%92) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %94
%94 = apply %82(%91, %93) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %95
%95 = apply %84(%94, %11) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %96
cond_fail %95 : $Builtin.Int1 // id: %96
%97 = unchecked_ref_bit_cast %88 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %98
%98 = ref_to_raw_pointer %97 : $Builtin.NativeObject to $Builtin.RawPointer // user: %103
%99 = metatype $@thick Int8.Type // user: %100
%100 = apply %45<Int8>(%99) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %101
%101 = apply %47(%27, %100, %18) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %102
%102 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 0 // user: %103
%103 = index_raw_pointer %98 : $Builtin.RawPointer, %102 : $Builtin.Word // user: %105
%104 = load %1 : $*_ArrayBody // user: %106
%105 = pointer_to_address %103 : $Builtin.RawPointer to $*_ArrayBody // user: %106
store %104 to %105 : $*_ArrayBody // id: %106
return %89 : $HeapBuffer<_ArrayBody, Int> // id: %107
}
// specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.Optional.init <A>(Swift.Optional<A>.Type)(nilLiteral : ()) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.Optional.init <A>(A?.Type)(nilLiteral : ()) -> A? : $@thin (@out Optional<HeapBufferStorage<_ArrayBody, Int>>, @thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type) -> () {
bb0(%0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %1 : $@thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type):
// function_ref Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
%2 = function_ref Swift.Optional.None <A>(A?.Type) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> () // user: %5
%3 = metatype $@thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %5
%4 = alloc_stack $Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %5, %6, %7
%5 = apply [transparent] %2<HeapBufferStorage<_ArrayBody, Int>>(%4#1, %3) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @thin Optional<τ_0_0>.Type) -> ()
%6 = load %4#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %8
dealloc_stack %4#0 : $*@local_storage Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %7
store %6 to %0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._requiredAlignMask <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin (@thin HeapBuffer<_ArrayBody, Int>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<_ArrayBody, Int>.Type):
%1 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %3, %11, %16
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %7
%4 = integer_literal $Builtin.Word, 1 // users: %7, %12, %17
%5 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %7, %12, %17
%6 = integer_literal $Builtin.Int1, 0 // users: %7, %12, %17
%7 = apply %5(%3, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %8
%8 = tuple_extract %7 : $(Builtin.Word, Builtin.Int1), 0 // users: %9, %21, %29
%9 = struct $Int (%8 : $Builtin.Word) // user: %32
%10 = metatype $@thick _ArrayBody.Type // user: %11
%11 = apply %1<_ArrayBody>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %12
%12 = apply %5(%11, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %13
%13 = tuple_extract %12 : $(Builtin.Word, Builtin.Int1), 0 // users: %14, %21, %23
%14 = struct $Int (%13 : $Builtin.Word) // user: %28
%15 = metatype $@thick Int.Type // user: %16
%16 = apply %1<Int>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %17
%17 = apply %5(%16, %4, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %18
%18 = tuple_extract %17 : $(Builtin.Word, Builtin.Int1), 0 // users: %19, %23, %29
%19 = struct $Int (%18 : $Builtin.Word) // users: %25, %31
%20 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %21, %23, %29
%21 = apply %20(%8, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
cond_br %21, bb1, bb5 // id: %22
bb1: // Preds: bb0
%23 = apply %20(%13, %18) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
cond_br %23, bb2, bb4 // id: %24
bb2: // Preds: bb1
br bb3(%19 : $Int) // id: %25
bb3(%26 : $Int): // Preds: bb2 bb4 bb6 bb7
return %26 : $Int // id: %27
bb4: // Preds: bb1
br bb3(%14 : $Int) // id: %28
bb5: // Preds: bb0
%29 = apply %20(%8, %18) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %30
cond_br %29, bb6, bb7 // id: %30
bb6: // Preds: bb5
br bb3(%19 : $Int) // id: %31
bb7: // Preds: bb5
br bb3(%9 : $Int) // id: %32
}
// specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift._injectValueIntoOptional <A>(A) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift._injectValueIntoOptional <A>(A) -> A? : $@thin (@out Optional<HeapBufferStorage<_ArrayBody, Int>>, @in HeapBufferStorage<_ArrayBody, Int>) -> () {
bb0(%0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %1 : $*HeapBufferStorage<_ArrayBody, Int>):
// function_ref Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
%2 = function_ref Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> () // user: %8
%3 = metatype $@thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %8
%4 = alloc_stack $HeapBufferStorage<_ArrayBody, Int> // users: %6, %8, %9
%5 = load %1 : $*HeapBufferStorage<_ArrayBody, Int> // users: %6, %7
store %5 to %4#1 : $*HeapBufferStorage<_ArrayBody, Int> // id: %6
strong_retain %5 : $HeapBufferStorage<_ArrayBody, Int> // id: %7
%8 = apply [transparent] %2<HeapBufferStorage<_ArrayBody, Int>>(%0, %4#1, %3) : $@thin <τ_0_0> (@out Optional<τ_0_0>, @in τ_0_0, @thin Optional<τ_0_0>.Type) -> ()
dealloc_stack %4#0 : $*@local_storage HeapBufferStorage<_ArrayBody, Int> // id: %9
%10 = load %1 : $*HeapBufferStorage<_ArrayBody, Int> // user: %11
strong_release %10 : $HeapBufferStorage<_ArrayBody, Int> // id: %11
%12 = tuple () // user: %13
return %12 : $() // id: %13
}
// specialization <Swift.Int> of Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool
sil shared specialization <Swift.Int> of Swift._isBridgedVerbatimToObjectiveC <A>(A.Type) -> Swift.Bool : $@thin (@thick Int.Type) -> Bool {
bb0(%0 : $@thick Int.Type):
%1 = integer_literal $Builtin.Int1, 0 // user: %2
%2 = struct $Bool (%1 : $Builtin.Int1) // user: %3
return %2 : $Bool // id: %3
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._capacity <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> Int {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
// function_ref malloc_size
%1 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %17
%2 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %14, %18
%3 = integer_literal $Builtin.Int1, -1 // users: %12, %26, %43, %49, %59
%4 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %8, %21, %42
%5 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %6
%6 = apply %4<HeapBufferStorage<_ArrayBody, Int>?>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%7 = metatype $@thick Builtin.NativeObject.Type // user: %8
%8 = apply %4<Builtin.NativeObject>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%9 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %10, %66, %69, %70
%10 = apply %9(%6, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %12
%11 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
%12 = apply %11(%10, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %13
cond_fail %12 : $Builtin.Int1 // id: %13
%14 = unchecked_ref_bit_cast %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %15
%15 = ref_to_raw_pointer %14 : $Builtin.NativeObject to $Builtin.RawPointer // user: %16
%16 = struct $UnsafePointer<()> (%15 : $Builtin.RawPointer) // user: %17
%17 = apply %1(%16) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %19
release_value %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %18
%19 = struct_extract %17 : $UInt, #UInt.value // user: %59
%20 = metatype $@thick HeapObject.Type // user: %21
%21 = apply %4<HeapObject>(%20) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%22 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %24, %48
%23 = metatype $@thick _ArrayBody.Type // users: %24, %42
%24 = apply %22<_ArrayBody>(%23) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %26, %35
%25 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %26, %43, %49
%26 = apply %25(%21, %24, %3) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %27, %28
%27 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 0 // user: %33
%28 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 1 // user: %29
cond_fail %28 : $Builtin.Int1 // id: %29
%30 = integer_literal $Builtin.Word, 1 // users: %33, %35, %53, %55
%31 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %33, %35, %53, %55, %59
%32 = integer_literal $Builtin.Int1, 0 // users: %33, %35, %53, %55
%33 = apply %31(%27, %30, %32) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %34
%34 = tuple_extract %33 : $(Builtin.Word, Builtin.Int1), 0 // user: %41
%35 = apply %31(%24, %30, %32) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %36
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %39
%37 = integer_literal $Builtin.Word, -1 // users: %39, %57, %70
%38 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %39, %57
%39 = apply %38(%36, %37) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %41
%40 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %41, %58
%41 = apply %40(%34, %39) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %43
%42 = apply %4<_ArrayBody>(%23) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %43
%43 = apply %25(%41, %42, %3) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %44, %45
%44 = tuple_extract %43 : $(Builtin.Word, Builtin.Int1), 0 // user: %49
%45 = tuple_extract %43 : $(Builtin.Word, Builtin.Int1), 1 // user: %46
cond_fail %45 : $Builtin.Int1 // id: %46
%47 = metatype $@thick Int.Type // users: %48, %64
%48 = apply %22<Int>(%47) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %49, %55
%49 = apply %25(%44, %48, %3) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %50, %51
%50 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 0 // user: %53
%51 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 1 // user: %52
cond_fail %51 : $Builtin.Int1 // id: %52
%53 = apply %31(%50, %30, %32) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %54
%54 = tuple_extract %53 : $(Builtin.Word, Builtin.Int1), 0 // user: %58
%55 = apply %31(%48, %30, %32) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %56
%56 = tuple_extract %55 : $(Builtin.Word, Builtin.Int1), 0 // user: %57
%57 = apply %38(%56, %37) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %58
%58 = apply %40(%54, %57) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %59
%59 = apply %31(%19, %58, %3) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %60, %61
%60 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 0 // users: %69, %75
%61 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 1 // user: %62
cond_fail %61 : $Builtin.Int1 // id: %62
%63 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %64
%64 = apply %63<Int>(%47) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %66, %70, %75
%65 = integer_literal $Builtin.Word, 0 // user: %66
%66 = apply %9(%64, %65) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %67
cond_fail %66 : $Builtin.Int1 // id: %67
%68 = integer_literal $Builtin.Word, -9223372036854775808 // user: %69
%69 = apply %9(%60, %68) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
%70 = apply %9(%64, %37) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
%71 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %72
%72 = apply %71(%69, %70) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %73
cond_fail %72 : $Builtin.Int1 // id: %73
%74 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %75
%75 = apply %74(%60, %64) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %76
%76 = struct $Int (%75 : $Builtin.Word) // user: %77
return %76 : $Int // id: %77
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._allocatedSize <A, B>(Swift.HeapBuffer<A, B>)() -> Swift.Int : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> Int {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
// function_ref malloc_size
%1 = function_ref @malloc_size : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %17
%2 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %14, %18
%3 = integer_literal $Builtin.Int1, -1 // user: %12
%4 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %8
%5 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %6
%6 = apply %4<HeapBufferStorage<_ArrayBody, Int>?>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%7 = metatype $@thick Builtin.NativeObject.Type // user: %8
%8 = apply %4<Builtin.NativeObject>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %10
%9 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %10
%10 = apply %9(%6, %8) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %12
%11 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
%12 = apply %11(%10, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %13
cond_fail %12 : $Builtin.Int1 // id: %13
%14 = unchecked_ref_bit_cast %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %15
%15 = ref_to_raw_pointer %14 : $Builtin.NativeObject to $Builtin.RawPointer // user: %16
%16 = struct $UnsafePointer<()> (%15 : $Builtin.RawPointer) // user: %17
%17 = apply %1(%16) : $@cc(cdecl) @thin (UnsafePointer<()>) -> UInt // user: %19
release_value %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %18
%19 = struct_extract %17 : $UInt, #UInt.value // user: %20
%20 = struct $Int (%19 : $Builtin.Word) // user: %21
return %20 : $Int // id: %21
}
// specialization <Swift.Int> of Swift.strideof <A>(A.Type) -> Swift.Int
sil shared [transparent] specialization <Swift.Int> of Swift.strideof <A>(A.Type) -> Swift.Int : $@thin (@thick Int.Type) -> Int {
bb0(%0 : $@thick Int.Type):
%1 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick Int.Type // user: %3
%3 = apply %1<Int>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.value.setter : A
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.value.setter : A : $@cc(method) @thin (@in _ArrayBody, @owned HeapBuffer<_ArrayBody, Int>) -> () {
bb0(%0 : $*_ArrayBody, %1 : $HeapBuffer<_ArrayBody, Int>):
%2 = load %0 : $*_ArrayBody // user: %47
%3 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %5, %29, %31
%4 = metatype $@thick HeapObject.Type // user: %5
%5 = apply %3<HeapObject>(%4) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %11
%6 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %8
%7 = metatype $@thick _ArrayBody.Type // user: %8
%8 = apply %6<_ArrayBody>(%7) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %11, %20
%9 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %11
%10 = integer_literal $Builtin.Int1, -1 // users: %11, %35
%11 = apply %9(%5, %8, %10) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %12, %13
%12 = tuple_extract %11 : $(Builtin.Word, Builtin.Int1), 0 // user: %18
%13 = tuple_extract %11 : $(Builtin.Word, Builtin.Int1), 1 // user: %14
cond_fail %13 : $Builtin.Int1 // id: %14
%15 = integer_literal $Builtin.Word, 1 // users: %18, %20
%16 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %18, %20
%17 = integer_literal $Builtin.Int1, 0 // users: %18, %20, %43
%18 = apply %16(%12, %15, %17) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %26
%20 = apply %16(%8, %15, %17) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %21
%21 = tuple_extract %20 : $(Builtin.Word, Builtin.Int1), 0 // user: %24
%22 = integer_literal $Builtin.Word, -1 // user: %24
%23 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%24 = apply %23(%21, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%25 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%26 = apply %25(%19, %24) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %43
%27 = struct_extract %1 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %37, %48
%28 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %29
%29 = apply %3<HeapBufferStorage<_ArrayBody, Int>?>(%28) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%30 = metatype $@thick Builtin.NativeObject.Type // user: %31
%31 = apply %3<Builtin.NativeObject>(%30) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%32 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %33
%33 = apply %32(%29, %31) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %35
%34 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %35
%35 = apply %34(%33, %10) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %36
cond_fail %35 : $Builtin.Int1 // id: %36
%37 = unchecked_ref_bit_cast %27 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %38
%38 = ref_to_raw_pointer %37 : $Builtin.NativeObject to $Builtin.RawPointer // user: %45
%39 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %41
%40 = metatype $@thick Int8.Type // user: %41
%41 = apply %39<Int8>(%40) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %43
%42 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = apply %42(%26, %41, %17) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %44
%44 = tuple_extract %43 : $(Builtin.Word, Builtin.Int1), 0 // user: %45
%45 = index_raw_pointer %38 : $Builtin.RawPointer, %44 : $Builtin.Word // user: %46
%46 = pointer_to_address %45 : $Builtin.RawPointer to $*_ArrayBody // user: %47
store %2 to %46 : $*_ArrayBody // id: %47
release_value %27 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %48
%49 = tuple () // user: %50
return %49 : $() // id: %50
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A>
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._value.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> UnsafeMutablePointer<_ArrayBody> {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %3, %27, %29
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%4 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %6
%5 = metatype $@thick _ArrayBody.Type // user: %6
%6 = apply %4<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %9, %18
%7 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %9
%8 = integer_literal $Builtin.Int1, -1 // users: %9, %33
%9 = apply %7(%3, %6, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %10, %11
%10 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 0 // user: %16
%11 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = integer_literal $Builtin.Word, 1 // users: %16, %18
%14 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %16, %18
%15 = integer_literal $Builtin.Int1, 0 // users: %16, %18, %42
%16 = apply %14(%10, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %24
%18 = apply %14(%6, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %22
%20 = integer_literal $Builtin.Word, -1 // user: %22
%21 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %22
%22 = apply %21(%19, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%23 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%24 = apply %23(%17, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %42
%25 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %35, %37
%26 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %27
%27 = apply %1<HeapBufferStorage<_ArrayBody, Int>?>(%26) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %31
%28 = metatype $@thick Builtin.NativeObject.Type // user: %29
%29 = apply %1<Builtin.NativeObject>(%28) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %31
%30 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %31
%31 = apply %30(%27, %29) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %33
%32 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %33
%33 = apply %32(%31, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %34
cond_fail %33 : $Builtin.Int1 // id: %34
%35 = unchecked_ref_bit_cast %25 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %36
%36 = ref_to_raw_pointer %35 : $Builtin.NativeObject to $Builtin.RawPointer // user: %44
release_value %25 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %37
%38 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %40
%39 = metatype $@thick Int8.Type // user: %40
%40 = apply %38<Int8>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %42
%41 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %42
%42 = apply %41(%24, %40, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%44 = index_raw_pointer %36 : $Builtin.RawPointer, %43 : $Builtin.Word // user: %45
%45 = struct $UnsafeMutablePointer<_ArrayBody> (%44 : $Builtin.RawPointer) // user: %46
return %45 : $UnsafeMutablePointer<_ArrayBody> // id: %46
}
// specialization <Swift._ArrayBody> of Swift.UnsafeMutablePointer.memory.setter : A
sil shared [transparent] specialization <Swift._ArrayBody> of Swift.UnsafeMutablePointer.memory.setter : A : $@cc(method) @thin (@in _ArrayBody, UnsafeMutablePointer<_ArrayBody>) -> () {
bb0(%0 : $*_ArrayBody, %1 : $UnsafeMutablePointer<_ArrayBody>):
%2 = load %0 : $*_ArrayBody // user: %5
%3 = struct_extract %1 : $UnsafeMutablePointer<_ArrayBody>, #UnsafeMutablePointer.value // user: %4
%4 = pointer_to_address %3 : $Builtin.RawPointer to $*_ArrayBody // user: %5
store %2 to %4 : $*_ArrayBody // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.Int> of Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A>
sil shared specialization <Swift.Int> of Swift._ContiguousArrayBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<A> : $@cc(method) @thin (@owned _ContiguousArrayBuffer<Int>) -> UnsafeMutablePointer<Int> {
bb0(%0 : $_ContiguousArrayBuffer<Int>):
%1 = struct_extract %0 : $_ContiguousArrayBuffer<Int>, #_ContiguousArrayBuffer._base // user: %2
%2 = struct_extract %1 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %3, %55, %57
%3 = enum_is_tag $Builtin.Int1, %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %4
cond_br %3, bb1, bb3 // id: %4
bb1: // Preds: bb0
%5 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %7, %29, %47, %49
%6 = metatype $@thick HeapObject.Type // user: %7
%7 = apply %5<HeapObject>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %13
%8 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %10, %35
%9 = metatype $@thick _ArrayBody.Type // users: %10, %29
%10 = apply %8<_ArrayBody>(%9) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %13, %22
%11 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %13, %30, %36
%12 = integer_literal $Builtin.Int1, -1 // users: %13, %30, %36, %53
%13 = apply %11(%7, %10, %12) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %14, %15
%14 = tuple_extract %13 : $(Builtin.Word, Builtin.Int1), 0 // user: %20
%15 = tuple_extract %13 : $(Builtin.Word, Builtin.Int1), 1 // user: %16
cond_fail %15 : $Builtin.Int1 // id: %16
%17 = integer_literal $Builtin.Word, 1 // users: %20, %22, %40, %42
%18 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %20, %22, %40, %42
%19 = integer_literal $Builtin.Int1, 0 // users: %20, %22, %40, %42, %63
%20 = apply %18(%14, %17, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %21
%21 = tuple_extract %20 : $(Builtin.Word, Builtin.Int1), 0 // user: %28
%22 = apply %18(%10, %17, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %23
%23 = tuple_extract %22 : $(Builtin.Word, Builtin.Int1), 0 // user: %26
%24 = integer_literal $Builtin.Word, -1 // users: %26, %44
%25 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %26, %44
%26 = apply %25(%23, %24) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %28
%27 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %28, %45
%28 = apply %27(%21, %26) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %30
%29 = apply %5<_ArrayBody>(%9) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %30
%30 = apply %11(%28, %29, %12) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %31, %32
%31 = tuple_extract %30 : $(Builtin.Word, Builtin.Int1), 0 // user: %36
%32 = tuple_extract %30 : $(Builtin.Word, Builtin.Int1), 1 // user: %33
cond_fail %32 : $Builtin.Int1 // id: %33
%34 = metatype $@thick Int.Type // user: %35
%35 = apply %8<Int>(%34) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %36, %42
%36 = apply %11(%31, %35, %12) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %37, %38
%37 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 0 // user: %40
%38 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 1 // user: %39
cond_fail %38 : $Builtin.Int1 // id: %39
%40 = apply %18(%37, %17, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %41
%41 = tuple_extract %40 : $(Builtin.Word, Builtin.Int1), 0 // user: %45
%42 = apply %18(%35, %17, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %44
%44 = apply %25(%43, %24) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %45
%45 = apply %27(%41, %44) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %63
%46 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %47
%47 = apply %5<HeapBufferStorage<_ArrayBody, Int>?>(%46) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %51
%48 = metatype $@thick Builtin.NativeObject.Type // user: %49
%49 = apply %5<Builtin.NativeObject>(%48) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %51
%50 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %51
%51 = apply %50(%47, %49) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %53
%52 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %53
%53 = apply %52(%51, %12) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %54
cond_fail %53 : $Builtin.Int1 // id: %54
%55 = unchecked_ref_bit_cast %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %56
%56 = ref_to_raw_pointer %55 : $Builtin.NativeObject to $Builtin.RawPointer // user: %65
%57 = unchecked_enum_data %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %58
strong_release %57 : $HeapBufferStorage<_ArrayBody, Int> // id: %58
%59 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %61
%60 = metatype $@thick Int8.Type // user: %61
%61 = apply %59<Int8>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %63
%62 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %63
%63 = apply %62(%45, %61, %19) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %64
%64 = tuple_extract %63 : $(Builtin.Word, Builtin.Int1), 0 // user: %65
%65 = index_raw_pointer %56 : $Builtin.RawPointer, %64 : $Builtin.Word // user: %66
%66 = struct $UnsafeMutablePointer<Int> (%65 : $Builtin.RawPointer) // user: %67
br bb2(%66 : $UnsafeMutablePointer<Int>) // id: %67
bb2(%68 : $UnsafeMutablePointer<Int>): // Preds: bb1 bb3
return %68 : $UnsafeMutablePointer<Int> // id: %69
bb3: // Preds: bb0
%70 = builtin_function_ref "inttoptr_Word" : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %72
%71 = integer_literal $Builtin.Word, 0 // user: %72
%72 = apply %70(%71) : $@thin (Builtin.Word) -> Builtin.RawPointer // user: %73
%73 = struct $UnsafeMutablePointer<Int> (%72 : $Builtin.RawPointer) // user: %74
br bb2(%73 : $UnsafeMutablePointer<Int>) // id: %74
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.hasStorage.getter : Swift.Bool
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.hasStorage.getter : Swift.Bool : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> Bool {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
%1 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %2, %3, %4
%2 = enum_is_tag $Builtin.Int1, %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %7
switch_enum %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb3 // id: %3
bb1: // Preds: bb0
%4 = unchecked_enum_data %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %5
strong_release %4 : $HeapBufferStorage<_ArrayBody, Int> // id: %5
br bb2 // id: %6
bb2: // Preds: bb1 bb3
%7 = struct $Bool (%2 : $Builtin.Int1) // user: %8
return %7 : $Bool // id: %8
bb3: // Preds: bb0
br bb2 // id: %9
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B>
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer.baseAddress.getter : Swift.UnsafeMutablePointer<B> : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> UnsafeMutablePointer<Int> {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %3, %25, %44, %46
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%4 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %31
%5 = metatype $@thick _ArrayBody.Type // users: %6, %25
%6 = apply %4<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %9, %18
%7 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %9, %26, %32
%8 = integer_literal $Builtin.Int1, -1 // users: %9, %26, %32, %50
%9 = apply %7(%3, %6, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %10, %11
%10 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 0 // user: %16
%11 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = integer_literal $Builtin.Word, 1 // users: %16, %18, %36, %38
%14 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %16, %18, %36, %38
%15 = integer_literal $Builtin.Int1, 0 // users: %16, %18, %36, %38, %59
%16 = apply %14(%10, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %24
%18 = apply %14(%6, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %22
%20 = integer_literal $Builtin.Word, -1 // users: %22, %40
%21 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %22, %40
%22 = apply %21(%19, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%23 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %24, %41
%24 = apply %23(%17, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%25 = apply %1<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%26 = apply %7(%24, %25, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %27, %28
%27 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 0 // user: %32
%28 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 1 // user: %29
cond_fail %28 : $Builtin.Int1 // id: %29
%30 = metatype $@thick Int.Type // user: %31
%31 = apply %4<Int>(%30) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %32, %38
%32 = apply %7(%27, %31, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %33, %34
%33 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 0 // user: %36
%34 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 1 // user: %35
cond_fail %34 : $Builtin.Int1 // id: %35
%36 = apply %14(%33, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %37
%37 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 0 // user: %41
%38 = apply %14(%31, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %39
%39 = tuple_extract %38 : $(Builtin.Word, Builtin.Int1), 0 // user: %40
%40 = apply %21(%39, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %41
%41 = apply %23(%37, %40) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %59
%42 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %52, %54
%43 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %44
%44 = apply %1<HeapBufferStorage<_ArrayBody, Int>?>(%43) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %48
%45 = metatype $@thick Builtin.NativeObject.Type // user: %46
%46 = apply %1<Builtin.NativeObject>(%45) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %48
%47 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %48
%48 = apply %47(%44, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %50
%49 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %50
%50 = apply %49(%48, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %51
cond_fail %50 : $Builtin.Int1 // id: %51
%52 = unchecked_ref_bit_cast %42 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %53
%53 = ref_to_raw_pointer %52 : $Builtin.NativeObject to $Builtin.RawPointer // user: %61
release_value %42 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %54
%55 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %57
%56 = metatype $@thick Int8.Type // user: %57
%57 = apply %55<Int8>(%56) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %59
%58 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %59
%59 = apply %58(%41, %57, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %60
%60 = tuple_extract %59 : $(Builtin.Word, Builtin.Int1), 0 // user: %61
%61 = index_raw_pointer %53 : $Builtin.RawPointer, %60 : $Builtin.Word // user: %62
%62 = struct $UnsafeMutablePointer<Int> (%61 : $Builtin.RawPointer) // user: %63
return %62 : $UnsafeMutablePointer<Int> // id: %63
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._elementOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin (@thin HeapBuffer<_ArrayBody, Int>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<_ArrayBody, Int>.Type):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %3, %25
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%4 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %6, %31
%5 = metatype $@thick _ArrayBody.Type // users: %6, %25
%6 = apply %4<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %9, %18
%7 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %9, %26, %32
%8 = integer_literal $Builtin.Int1, -1 // users: %9, %26, %32
%9 = apply %7(%3, %6, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %10, %11
%10 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 0 // user: %16
%11 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = integer_literal $Builtin.Word, 1 // users: %16, %18, %36, %38
%14 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %16, %18, %36, %38
%15 = integer_literal $Builtin.Int1, 0 // users: %16, %18, %36, %38
%16 = apply %14(%10, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %24
%18 = apply %14(%6, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %22
%20 = integer_literal $Builtin.Word, -1 // users: %22, %40
%21 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %22, %40
%22 = apply %21(%19, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%23 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %24, %41
%24 = apply %23(%17, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%25 = apply %1<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%26 = apply %7(%24, %25, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %27, %28
%27 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 0 // user: %32
%28 = tuple_extract %26 : $(Builtin.Word, Builtin.Int1), 1 // user: %29
cond_fail %28 : $Builtin.Int1 // id: %29
%30 = metatype $@thick Int.Type // user: %31
%31 = apply %4<Int>(%30) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %32, %38
%32 = apply %7(%27, %31, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %33, %34
%33 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 0 // user: %36
%34 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 1 // user: %35
cond_fail %34 : $Builtin.Int1 // id: %35
%36 = apply %14(%33, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %37
%37 = tuple_extract %36 : $(Builtin.Word, Builtin.Int1), 0 // user: %41
%38 = apply %14(%31, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %39
%39 = tuple_extract %38 : $(Builtin.Word, Builtin.Int1), 0 // user: %40
%40 = apply %21(%39, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %41
%41 = apply %23(%37, %40) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %42
%42 = struct $Int (%41 : $Builtin.Word) // user: %43
return %42 : $Int // id: %43
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._valueOffset <A, B>(Swift.HeapBuffer<A, B>.Type)() -> Swift.Int : $@thin (@thin HeapBuffer<_ArrayBody, Int>.Type) -> Int {
bb0(%0 : $@thin HeapBuffer<_ArrayBody, Int>.Type):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick HeapObject.Type // user: %3
%3 = apply %1<HeapObject>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%4 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %6
%5 = metatype $@thick _ArrayBody.Type // user: %6
%6 = apply %4<_ArrayBody>(%5) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %9, %18
%7 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %9
%8 = integer_literal $Builtin.Int1, -1 // user: %9
%9 = apply %7(%3, %6, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %10, %11
%10 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 0 // user: %16
%11 = tuple_extract %9 : $(Builtin.Word, Builtin.Int1), 1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = integer_literal $Builtin.Word, 1 // users: %16, %18
%14 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %16, %18
%15 = integer_literal $Builtin.Int1, 0 // users: %16, %18
%16 = apply %14(%10, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %17
%17 = tuple_extract %16 : $(Builtin.Word, Builtin.Int1), 0 // user: %24
%18 = apply %14(%6, %13, %15) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %19
%19 = tuple_extract %18 : $(Builtin.Word, Builtin.Int1), 0 // user: %22
%20 = integer_literal $Builtin.Word, -1 // user: %22
%21 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %22
%22 = apply %21(%19, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%23 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %24
%24 = apply %23(%17, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %25
%25 = struct $Int (%24 : $Builtin.Word) // user: %26
return %25 : $Int // id: %26
}
// specialization <Swift._ArrayBody> of Swift.alignof <A>(A.Type) -> Swift.Int
sil shared [transparent] specialization <Swift._ArrayBody> of Swift.alignof <A>(A.Type) -> Swift.Int : $@thin (@thick _ArrayBody.Type) -> Int {
bb0(%0 : $@thick _ArrayBody.Type):
%1 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick _ArrayBody.Type // user: %3
%3 = apply %1<_ArrayBody>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// specialization <Swift.Int> of Swift.alignof <A>(A.Type) -> Swift.Int
sil shared [transparent] specialization <Swift.Int> of Swift.alignof <A>(A.Type) -> Swift.Int : $@thin (@thick Int.Type) -> Int {
bb0(%0 : $@thick Int.Type):
%1 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick Int.Type // user: %3
%3 = apply %1<Int>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8>
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._address.getter : Swift.UnsafeMutablePointer<Swift.Int8> : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> UnsafeMutablePointer<Int8> {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
%1 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // users: %13, %16
%2 = integer_literal $Builtin.Int1, -1 // user: %11
%3 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %5, %7
%4 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %5
%5 = apply %3<HeapBufferStorage<_ArrayBody, Int>?>(%4) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%6 = metatype $@thick Builtin.NativeObject.Type // user: %7
%7 = apply %3<Builtin.NativeObject>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%8 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%9 = apply %8(%5, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %11
%10 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %11
%11 = apply %10(%9, %2) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = unchecked_ref_bit_cast %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %14
%14 = ref_to_raw_pointer %13 : $Builtin.NativeObject to $Builtin.RawPointer // user: %15
%15 = struct $UnsafeMutablePointer<Int8> (%14 : $Builtin.RawPointer) // user: %17
release_value %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %16
return %15 : $UnsafeMutablePointer<Int8> // id: %17
}
// specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject
sil shared specialization <Swift._ArrayBody, Swift.Int> of Swift.HeapBuffer._nativeObject.getter : Builtin.NativeObject : $@cc(method) @thin (@owned HeapBuffer<_ArrayBody, Int>) -> @owned Builtin.NativeObject {
bb0(%0 : $HeapBuffer<_ArrayBody, Int>):
%1 = struct_extract %0 : $HeapBuffer<_ArrayBody, Int>, #HeapBuffer.storage // user: %13
%2 = integer_literal $Builtin.Int1, -1 // user: %11
%3 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %5, %7
%4 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %5
%5 = apply %3<HeapBufferStorage<_ArrayBody, Int>?>(%4) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%6 = metatype $@thick Builtin.NativeObject.Type // user: %7
%7 = apply %3<Builtin.NativeObject>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %9
%8 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%9 = apply %8(%5, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %11
%10 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %11
%11 = apply %10(%9, %2) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = unchecked_ref_bit_cast %1 : $Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.NativeObject // user: %14
return %13 : $Builtin.NativeObject // id: %14
}
// specialization <Swift.AnyObject, Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B
sil shared [transparent] specialization <Swift.AnyObject, Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin (@out HeapBufferStorage<_ArrayBody, Int>, @in AnyObject, @thick HeapBufferStorage<_ArrayBody, Int>.Type) -> () {
bb0(%0 : $*HeapBufferStorage<_ArrayBody, Int>, %1 : $*AnyObject, %2 : $@thick HeapBufferStorage<_ArrayBody, Int>.Type):
%3 = alloc_stack $AnyObject // users: %5, %21, %25, %28
%4 = load %1 : $*AnyObject // user: %5
store %4 to %3#1 : $*AnyObject // id: %5
%6 = integer_literal $Builtin.Int1, -1 // user: %17
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%7 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %9, %11
%8 = metatype $@thick AnyObject.Protocol // user: %9
%9 = apply [transparent] %7<AnyObject>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%10 = metatype $@thick HeapBufferStorage<_ArrayBody, Int>.Type // user: %11
%11 = apply [transparent] %7<HeapBufferStorage<_ArrayBody, Int>>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %14
%12 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %15
%13 = struct_extract %9 : $Int, #Int.value // user: %15
%14 = struct_extract %11 : $Int, #Int.value // user: %15
%15 = apply %12(%13, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%19 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
%20 = metatype $@thin UnsafeMutablePointer<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %22
%21 = address_to_pointer %3#1 : $*AnyObject to $Builtin.RawPointer // user: %22
%22 = apply [transparent] %19<HeapBufferStorage<_ArrayBody, Int>>(%21, %20) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %24
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%23 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %24
%24 = apply [transparent] %23<HeapBufferStorage<_ArrayBody, Int>>(%0, %22) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
%25 = load %3#1 : $*AnyObject // user: %26
strong_release %25 : $AnyObject // id: %26
%27 = tuple () // user: %29
dealloc_stack %3#0 : $*@local_storage AnyObject // id: %28
return %27 : $() // id: %29
}
// specialization <Swift.Optional<Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>>, Builtin.NativeObject> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B
sil shared [transparent] specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>?, Builtin.NativeObject> of Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin (@out Builtin.NativeObject, @in Optional<HeapBufferStorage<_ArrayBody, Int>>, @thick Builtin.NativeObject.Type) -> () {
bb0(%0 : $*Builtin.NativeObject, %1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %2 : $@thick Builtin.NativeObject.Type):
%3 = alloc_stack $Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %5, %21, %25, %28
%4 = load %1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %5
store %4 to %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %5
%6 = integer_literal $Builtin.Int1, -1 // user: %17
// function_ref Swift.sizeof <A>(A.Type) -> Swift.Int
%7 = function_ref Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // users: %9, %11
%8 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %9
%9 = apply [transparent] %7<HeapBufferStorage<_ArrayBody, Int>?>(%8) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %13
%10 = metatype $@thick Builtin.NativeObject.Type // user: %11
%11 = apply [transparent] %7<Builtin.NativeObject>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %14
%12 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %15
%13 = struct_extract %9 : $Int, #Int.value // user: %15
%14 = struct_extract %11 : $Int, #Int.value // user: %15
%15 = apply %12(%13, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %6) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
// function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A>
%19 = function_ref Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(Builtin.RawPointer) -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %22
%20 = metatype $@thin UnsafeMutablePointer<Builtin.NativeObject>.Type // user: %22
%21 = address_to_pointer %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> to $Builtin.RawPointer // user: %22
%22 = apply [transparent] %19<Builtin.NativeObject>(%21, %20) : $@thin <τ_0_0> (Builtin.RawPointer, @thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %24
// function_ref Swift.UnsafeMutablePointer.memory.getter : A
%23 = function_ref Swift.UnsafeMutablePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> () // user: %24
%24 = apply [transparent] %23<Builtin.NativeObject>(%0, %22) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafeMutablePointer<τ_0_0>) -> ()
%25 = load %3#1 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %26
release_value %25 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %26
%27 = tuple () // user: %29
dealloc_stack %3#0 : $*@local_storage Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %28
return %27 : $() // id: %29
}
// specialization <Swift._ArrayBody, Swift.Int8> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A>
sil shared [transparent] specialization <Swift._ArrayBody, Swift.Int8> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A> : $@thin (UnsafeMutablePointer<Int8>, @thin UnsafeMutablePointer<_ArrayBody>.Type) -> UnsafeMutablePointer<_ArrayBody> {
bb0(%0 : $UnsafeMutablePointer<Int8>, %1 : $@thin UnsafeMutablePointer<_ArrayBody>.Type):
%2 = struct_extract %0 : $UnsafeMutablePointer<Int8>, #UnsafeMutablePointer.value // user: %3
%3 = struct $UnsafeMutablePointer<_ArrayBody> (%2 : $Builtin.RawPointer) // user: %4
return %3 : $UnsafeMutablePointer<_ArrayBody> // id: %4
}
// specialization <Swift.Int, Swift.Int8> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A>
sil shared [transparent] specialization <Swift.Int, Swift.Int8> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)<B>(Swift.UnsafeMutablePointer<B>) -> Swift.UnsafeMutablePointer<A> : $@thin (UnsafeMutablePointer<Int8>, @thin UnsafeMutablePointer<Int>.Type) -> UnsafeMutablePointer<Int> {
bb0(%0 : $UnsafeMutablePointer<Int8>, %1 : $@thin UnsafeMutablePointer<Int>.Type):
%2 = struct_extract %0 : $UnsafeMutablePointer<Int8>, #UnsafeMutablePointer.value // user: %3
%3 = struct $UnsafeMutablePointer<Int> (%2 : $Builtin.RawPointer) // user: %4
return %3 : $UnsafeMutablePointer<Int> // id: %4
}
// specialization <Swift.Int> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A>
sil shared [transparent] specialization <Swift.Int> of Swift.UnsafeMutablePointer.init <A>(Swift.UnsafeMutablePointer<A>.Type)(nilLiteral : ()) -> Swift.UnsafeMutablePointer<A> : $@thin (@thin UnsafeMutablePointer<Int>.Type) -> UnsafeMutablePointer<Int> {
bb0(%0 : $@thin UnsafeMutablePointer<Int>.Type):
// function_ref Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A>
%1 = function_ref Swift.UnsafeMutablePointer.null <A>(Swift.UnsafeMutablePointer<A>.Type)() -> Swift.UnsafeMutablePointer<A> : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %3
%2 = metatype $@thin UnsafeMutablePointer<Int>.Type // user: %3
%3 = apply [transparent] %1<Int>(%2) : $@thin <τ_0_0> (@thin UnsafeMutablePointer<τ_0_0>.Type) -> UnsafeMutablePointer<τ_0_0> // user: %4
return %3 : $UnsafeMutablePointer<Int> // id: %4
}
// specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> ()
sil shared specialization <Swift.UnsafeBufferPointer<Swift.Int> with Swift.UnsafeBufferPointer<Swift.Int> : Swift.CollectionType, Swift.UnsafeBufferPointerGenerator<Swift.Int> with Swift.UnsafeBufferPointerGenerator<Swift.Int> : Swift.GeneratorType, Swift.Int, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift._expectEnd <A : Swift.CollectionType>(A.Index, A) -> () : $@thin (@in Int, @in UnsafeBufferPointer<Int>) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<Int>):
%2 = tuple () // user: %3
return %2 : $() // id: %3
}
// specialization <Swift.Int> of Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> ()
sil shared specialization <Swift.Int> of Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> () : $@cc(method) @thin (@in Int, UnsafeMutablePointer<Int>) -> () {
bb0(%0 : $*Int, %1 : $UnsafeMutablePointer<Int>):
%2 = load %0 : $*Int // user: %5
%3 = struct_extract %1 : $UnsafeMutablePointer<Int>, #UnsafeMutablePointer.value // user: %4
%4 = pointer_to_address %3 : $Builtin.RawPointer to $*Int // user: %5
store %2 to %4 : $*Int // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift._ArrayBody> of Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> ()
sil shared specialization <Swift._ArrayBody> of Swift.UnsafeMutablePointer.initialize <A>(Swift.UnsafeMutablePointer<A>)(A) -> () : $@cc(method) @thin (@in _ArrayBody, UnsafeMutablePointer<_ArrayBody>) -> () {
bb0(%0 : $*_ArrayBody, %1 : $UnsafeMutablePointer<_ArrayBody>):
%2 = load %0 : $*_ArrayBody // user: %5
%3 = struct_extract %1 : $UnsafeMutablePointer<_ArrayBody>, #UnsafeMutablePointer.value // user: %4
%4 = pointer_to_address %3 : $Builtin.RawPointer to $*_ArrayBody // user: %5
store %2 to %4 : $*_ArrayBody // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift._ArrayBody> of Swift.sizeof <A>(A.Type) -> Swift.Int
sil shared [transparent] specialization <Swift._ArrayBody> of Swift.sizeof <A>(A.Type) -> Swift.Int : $@thin (@thick _ArrayBody.Type) -> Int {
bb0(%0 : $@thick _ArrayBody.Type):
%1 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %3
%2 = metatype $@thick _ArrayBody.Type // user: %3
%3 = apply %1<_ArrayBody>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %4
%4 = struct $Int (%3 : $Builtin.Word) // user: %5
return %4 : $Int // id: %5
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType : $@cc(witness_method) @thin (@out Int, @inout LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Int, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%2 = integer_literal $Builtin.Word, 0 // user: %3
%3 = struct $Int (%2 : $Builtin.Word) // user: %4
store %3 to %0 : $*Int // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.startIndex.getter : A.Index
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.startIndex.getter : A.Index : $@cc(method) @thin (@out Int, @in LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Int, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %3, %4
%3 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %8
%4 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // user: %11
%5 = integer_literal $Builtin.Word, 0 // user: %6
%6 = struct $Int (%5 : $Builtin.Word) // user: %7
store %6 to %0 : $*Int // id: %7
%8 = struct_element_addr %3 : $*Array<Int>, #Array._buffer // user: %9
%9 = struct_element_addr %8 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %10
%10 = load %9 : $*Optional<Builtin.NativeObject> // user: %12
%11 = load %4 : $*@callee_owned (@out Bool, @in Int) -> () // user: %13
release_value %10 : $Optional<Builtin.NativeObject> // id: %12
strong_release %11 : $@callee_owned (@out Bool, @in Int) -> () // id: %13
%14 = tuple () // user: %15
return %14 : $() // id: %15
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.LazyForwardCollection : Swift._CollectionType : $@cc(witness_method) @thin (@out Int, @inout LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Int, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // user: %3
%3 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %4
%4 = struct_element_addr %3 : $*Array<Int>, #Array._buffer // user: %5
%5 = struct_element_addr %4 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %6
%6 = load %5 : $*Optional<Builtin.NativeObject> // users: %23, %55, %75
%7 = integer_literal $Builtin.Int1, -1 // users: %16, %21, %32, %53
%8 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %10, %12, %19, %27, %49, %51
%9 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %10
%10 = apply %8<Builtin.NativeObject?>(%9) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %14
%11 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %12
%12 = apply %8<_ContiguousArrayStorage<Int>?>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %14, %20
%13 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %14, %20, %52
%14 = apply %13(%10, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
%15 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %16, %21, %53
%16 = apply %15(%14, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
cond_fail %16 : $Builtin.Int1 // id: %17
%18 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %19
%19 = apply %8<HeapBuffer<_ArrayBody, Int>>(%18) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %20
%20 = apply %13(%12, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %21
%21 = apply %15(%20, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %22
cond_fail %21 : $Builtin.Int1 // id: %22
%23 = unchecked_ref_bit_cast %6 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %24
%24 = enum_is_tag $Builtin.Int1, %23 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %25
cond_br %24, bb1, bb3 // id: %25
bb1: // Preds: bb0
%26 = metatype $@thick HeapObject.Type // user: %27
%27 = apply %8<HeapObject>(%26) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %32
%28 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %30
%29 = metatype $@thick _ArrayBody.Type // user: %30
%30 = apply %28<_ArrayBody>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %32, %41
%31 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %32
%32 = apply %31(%27, %30, %7) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %33, %34
%33 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 0 // user: %39
%34 = tuple_extract %32 : $(Builtin.Word, Builtin.Int1), 1 // user: %35
cond_fail %34 : $Builtin.Int1 // id: %35
%36 = integer_literal $Builtin.Word, 1 // users: %39, %41
%37 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %39, %41
%38 = integer_literal $Builtin.Int1, 0 // users: %39, %41, %61
%39 = apply %37(%33, %36, %38) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %40
%40 = tuple_extract %39 : $(Builtin.Word, Builtin.Int1), 0 // user: %47
%41 = apply %37(%30, %36, %38) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %42
%42 = tuple_extract %41 : $(Builtin.Word, Builtin.Int1), 0 // user: %45
%43 = integer_literal $Builtin.Word, -1 // user: %45
%44 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %45
%45 = apply %44(%42, %43) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %47
%46 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %47
%47 = apply %46(%40, %45) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %61
%48 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %49
%49 = apply %8<HeapBufferStorage<_ArrayBody, Int>?>(%48) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %52
%50 = metatype $@thick Builtin.NativeObject.Type // user: %51
%51 = apply %8<Builtin.NativeObject>(%50) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %52
%52 = apply %13(%49, %51) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %53
%53 = apply %15(%52, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %54
cond_fail %53 : $Builtin.Int1 // id: %54
%55 = unchecked_ref_bit_cast %6 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %56
%56 = ref_to_raw_pointer %55 : $Builtin.NativeObject to $Builtin.RawPointer // user: %63
%57 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %59
%58 = metatype $@thick Int8.Type // user: %59
%59 = apply %57<Int8>(%58) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %61
%60 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %61
%61 = apply %60(%47, %59, %38) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %62
%62 = tuple_extract %61 : $(Builtin.Word, Builtin.Int1), 0 // user: %63
%63 = index_raw_pointer %56 : $Builtin.RawPointer, %62 : $Builtin.Word // user: %64
%64 = pointer_to_address %63 : $Builtin.RawPointer to $*_ArrayBody // user: %65
%65 = struct_element_addr %64 : $*_ArrayBody, #_ArrayBody.count // user: %66
%66 = struct_element_addr %65 : $*Int, #Int.value // user: %67
%67 = load %66 : $*Builtin.Word // user: %68
br bb2(%67 : $Builtin.Word) // id: %68
bb2(%69 : $Builtin.Word): // Preds: bb1 bb3
%70 = struct $Int (%69 : $Builtin.Word) // user: %71
store %70 to %0 : $*Int // id: %71
%72 = tuple () // user: %73
return %72 : $() // id: %73
bb3: // Preds: bb0
%74 = integer_literal $Builtin.Word, 0 // user: %76
retain_value %6 : $Optional<Builtin.NativeObject> // id: %75
br bb2(%74 : $Builtin.Word) // id: %76
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.endIndex.getter : A.Index
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.endIndex.getter : A.Index : $@cc(method) @thin (@out Int, @in LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Int, %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%2 = struct_element_addr %1 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %3, %7
%3 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %4
%4 = struct_element_addr %3 : $*Array<Int>, #Array._buffer // user: %5
%5 = struct_element_addr %4 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %6, %73
%6 = load %5 : $*Optional<Builtin.NativeObject> // users: %24, %56, %80
%7 = struct_element_addr %2 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // user: %74
%8 = integer_literal $Builtin.Int1, -1 // users: %17, %22, %33, %54
%9 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %11, %13, %20, %28, %50, %52
%10 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %11
%11 = apply %9<Builtin.NativeObject?>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %15
%12 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %13
%13 = apply %9<_ContiguousArrayStorage<Int>?>(%12) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %15, %21
%14 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %15, %21, %53
%15 = apply %14(%11, %13) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %17, %22, %54
%17 = apply %16(%15, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_fail %17 : $Builtin.Int1 // id: %18
%19 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %20
%20 = apply %9<HeapBuffer<_ArrayBody, Int>>(%19) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %21
%21 = apply %14(%13, %20) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%22 = apply %16(%21, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = unchecked_ref_bit_cast %6 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %25
%25 = enum_is_tag $Builtin.Int1, %24 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %26
cond_br %25, bb1, bb3 // id: %26
bb1: // Preds: bb0
%27 = metatype $@thick HeapObject.Type // user: %28
%28 = apply %9<HeapObject>(%27) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%29 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %31
%30 = metatype $@thick _ArrayBody.Type // user: %31
%31 = apply %29<_ArrayBody>(%30) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %33, %42
%32 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %33
%33 = apply %32(%28, %31, %8) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %34, %35
%34 = tuple_extract %33 : $(Builtin.Word, Builtin.Int1), 0 // user: %40
%35 = tuple_extract %33 : $(Builtin.Word, Builtin.Int1), 1 // user: %36
cond_fail %35 : $Builtin.Int1 // id: %36
%37 = integer_literal $Builtin.Word, 1 // users: %40, %42
%38 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %40, %42
%39 = integer_literal $Builtin.Int1, 0 // users: %40, %42, %62
%40 = apply %38(%34, %37, %39) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %41
%41 = tuple_extract %40 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%42 = apply %38(%31, %37, %39) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %46
%44 = integer_literal $Builtin.Word, -1 // user: %46
%45 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %46
%46 = apply %45(%43, %44) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %48
%47 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %48
%48 = apply %47(%41, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %62
%49 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %50
%50 = apply %9<HeapBufferStorage<_ArrayBody, Int>?>(%49) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %53
%51 = metatype $@thick Builtin.NativeObject.Type // user: %52
%52 = apply %9<Builtin.NativeObject>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %53
%53 = apply %14(%50, %52) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %54
%54 = apply %16(%53, %8) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %55
cond_fail %54 : $Builtin.Int1 // id: %55
%56 = unchecked_ref_bit_cast %6 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %57
%57 = ref_to_raw_pointer %56 : $Builtin.NativeObject to $Builtin.RawPointer // user: %64
%58 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %60
%59 = metatype $@thick Int8.Type // user: %60
%60 = apply %58<Int8>(%59) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%61 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %62
%62 = apply %61(%48, %60, %39) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %63
%63 = tuple_extract %62 : $(Builtin.Word, Builtin.Int1), 0 // user: %64
%64 = index_raw_pointer %57 : $Builtin.RawPointer, %63 : $Builtin.Word // user: %65
%65 = pointer_to_address %64 : $Builtin.RawPointer to $*_ArrayBody // user: %66
%66 = struct_element_addr %65 : $*_ArrayBody, #_ArrayBody.count // user: %67
%67 = struct_element_addr %66 : $*Int, #Int.value // user: %68
%68 = load %67 : $*Builtin.Word // user: %69
br bb2(%68 : $Builtin.Word) // id: %69
bb2(%70 : $Builtin.Word): // Preds: bb1 bb3
%71 = struct $Int (%70 : $Builtin.Word) // user: %72
store %71 to %0 : $*Int // id: %72
%73 = load %5 : $*Optional<Builtin.NativeObject> // user: %75
%74 = load %7 : $*@callee_owned (@out Bool, @in Int) -> () // user: %76
release_value %73 : $Optional<Builtin.NativeObject> // id: %75
strong_release %74 : $@callee_owned (@out Bool, @in Int) -> () // id: %76
%77 = tuple () // user: %78
return %77 : $() // id: %78
bb3: // Preds: bb0
%79 = integer_literal $Builtin.Word, 0 // user: %81
retain_value %6 : $Optional<Builtin.NativeObject> // id: %80
br bb2(%79 : $Builtin.Word) // id: %81
}
// protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.MapCollectionView : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.MapCollectionView : Swift._CollectionType : $@cc(witness_method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>.Index, @inout MapCollectionView<Base, T>) -> () {
bb0(%0 : $*Base.Index, %1 : $*MapCollectionView<Base, T>):
%2 = alloc_stack $MapCollectionView<Base, T> // users: %3, %5, %6
copy_addr %1 to [initialization] %2#1 : $*MapCollectionView<Base, T> // id: %3
// function_ref Swift.MapCollectionView.startIndex.getter : A.Index
%4 = function_ref Swift.MapCollectionView.startIndex.getter : A.Index : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %5
%5 = apply %4<Base, T, Base.Generator, Base.Generator.Element, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %2#1) : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %7
dealloc_stack %2#0 : $*@local_storage MapCollectionView<Base, T> // id: %6
return %5 : $() // id: %7
}
// protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.MapCollectionView : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.MapCollectionView : Swift._CollectionType : $@cc(witness_method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>.Index, @inout MapCollectionView<Base, T>) -> () {
bb0(%0 : $*Base.Index, %1 : $*MapCollectionView<Base, T>):
%2 = alloc_stack $MapCollectionView<Base, T> // users: %3, %5, %6
copy_addr %1 to [initialization] %2#1 : $*MapCollectionView<Base, T> // id: %3
// function_ref Swift.MapCollectionView.endIndex.getter : A.Index
%4 = function_ref Swift.MapCollectionView.endIndex.getter : A.Index : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %5
%5 = apply %4<Base, T, Base.Generator, Base.Generator.Element, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %2#1) : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %7
dealloc_stack %2#0 : $*@local_storage MapCollectionView<Base, T> // id: %6
return %5 : $() // id: %7
}
// protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.MapCollectionView : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.MapCollectionView : Swift._CollectionType : $@cc(witness_method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>._Element, @in MapCollectionView<Base, T>.Index, @inout MapCollectionView<Base, T>) -> () {
bb0(%0 : $*T, %1 : $*Base.Index, %2 : $*MapCollectionView<Base, T>):
%3 = alloc_stack $MapCollectionView<Base, T> // users: %4, %6, %7
copy_addr %2 to [initialization] %3#1 : $*MapCollectionView<Base, T> // id: %4
// function_ref Swift.MapCollectionView.subscript.getter (A.Index) -> B
%5 = function_ref Swift.MapCollectionView.subscript.getter (A.Index) -> B : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %6
%6 = apply %5<Base, T, Base.Generator, Base.Generator.Element, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %1, %3#1) : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %8
dealloc_stack %3#0 : $*@local_storage MapCollectionView<Base, T> // id: %7
return %6 : $() // id: %8
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.LazyForwardCollection : Swift.CollectionType
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.LazyForwardCollection : Swift.CollectionType : $@cc(witness_method) @thin (@out Bool, @in Int, @inout LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Bool, %1 : $*Int, %2 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%3 = struct_element_addr %2 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %4, %8
%4 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %5
%5 = struct_element_addr %4 : $*Array<Int>, #Array._buffer // user: %6
%6 = struct_element_addr %5 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %7
%7 = load %6 : $*Optional<Builtin.NativeObject> // users: %29, %65
%8 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // user: %9
%9 = load %8 : $*@callee_owned (@out Bool, @in Int) -> () // users: %118, %119
%10 = struct_element_addr %1 : $*Int, #Int.value // user: %11
%11 = load %10 : $*Builtin.Word // users: %35, %79, %85, %85, %88, %91, %115
%12 = alloc_stack $Int // users: %117, %119, %120
%13 = integer_literal $Builtin.Int1, -1 // users: %22, %27, %31, %42, %63, %82, %86, %92, %95, %101
%14 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %18, %25, %37, %59, %61, %94
%15 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %16
%16 = apply %14<Builtin.NativeObject?>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %20
%17 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %18
%18 = apply %14<_ContiguousArrayStorage<Int>?>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %20, %26
%19 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %20, %26, %62
%20 = apply %19(%16, %18) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%21 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %22, %27, %31, %63, %82, %86, %92
%22 = apply %21(%20, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %25
%25 = apply %14<HeapBuffer<_ArrayBody, Int>>(%24) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%26 = apply %19(%18, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %27
%27 = apply %21(%26, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %28
cond_fail %27 : $Builtin.Int1 // id: %28
%29 = unchecked_ref_bit_cast %7 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %30
%30 = enum_is_tag $Builtin.Int1, %29 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %31
%31 = apply %21(%30, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %32
cond_fail %31 : $Builtin.Int1 // id: %32
%33 = integer_literal $Builtin.Word, 0 // user: %35
%34 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %35
%35 = apply %34(%11, %33) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %81
%36 = metatype $@thick HeapObject.Type // user: %37
%37 = apply %14<HeapObject>(%36) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %42
%38 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %40, %100
%39 = metatype $@thick _ArrayBody.Type // users: %40, %94
%40 = apply %38<_ArrayBody>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %42, %51
%41 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %88, %95, %101
%42 = apply %41(%37, %40, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %43, %44
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %49
%44 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 1 // user: %45
cond_fail %44 : $Builtin.Int1 // id: %45
%46 = integer_literal $Builtin.Word, 1 // users: %49, %51, %88, %105, %107
%47 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %49, %51, %105, %107
%48 = integer_literal $Builtin.Int1, 0 // users: %49, %51, %71, %88, %105, %107, %111
%49 = apply %47(%43, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %50
%50 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 0 // user: %57
%51 = apply %47(%40, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %52
%52 = tuple_extract %51 : $(Builtin.Word, Builtin.Int1), 0 // user: %55
%53 = integer_literal $Builtin.Word, -1 // users: %55, %109
%54 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %55, %109
%55 = apply %54(%52, %53) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %57
%56 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %57, %110
%57 = apply %56(%50, %55) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %71, %95
%58 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %59
%59 = apply %14<HeapBufferStorage<_ArrayBody, Int>?>(%58) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%60 = metatype $@thick Builtin.NativeObject.Type // user: %61
%61 = apply %14<Builtin.NativeObject>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%62 = apply %19(%59, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %63
%63 = apply %21(%62, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %64
cond_fail %63 : $Builtin.Int1 // id: %64
%65 = unchecked_ref_bit_cast %7 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %66
%66 = ref_to_raw_pointer %65 : $Builtin.NativeObject to $Builtin.RawPointer // users: %73, %113
%67 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %69
%68 = metatype $@thick Int8.Type // user: %69
%69 = apply %67<Int8>(%68) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %71, %111
%70 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %71, %111
%71 = apply %70(%57, %69, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %72
%72 = tuple_extract %71 : $(Builtin.Word, Builtin.Int1), 0 // user: %73
%73 = index_raw_pointer %66 : $Builtin.RawPointer, %72 : $Builtin.Word // user: %74
%74 = pointer_to_address %73 : $Builtin.RawPointer to $*_ArrayBody // user: %75
%75 = struct_element_addr %74 : $*_ArrayBody, #_ArrayBody.count // user: %76
%76 = struct_element_addr %75 : $*Int, #Int.value // user: %77
%77 = load %76 : $*Builtin.Word // user: %79
%78 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %79
%79 = apply %78(%11, %77) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %81
%80 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %81
%81 = apply %80(%35, %79) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %82
%82 = apply %21(%81, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %83
cond_fail %82 : $Builtin.Int1 // id: %83
%84 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %85
%85 = apply %84(%11, %11) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %86
%86 = apply %21(%85, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %87
cond_fail %86 : $Builtin.Int1 // id: %87
%88 = apply %41(%11, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %89
%89 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 0 // user: %91
%90 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %91
%91 = apply %90(%89, %11) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %92
%92 = apply %21(%91, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %93
cond_fail %92 : $Builtin.Int1 // id: %93
%94 = apply %14<_ArrayBody>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %95
%95 = apply %41(%57, %94, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %96, %97
%96 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 0 // user: %101
%97 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = metatype $@thick Int.Type // user: %100
%100 = apply %38<Int>(%99) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %101, %107
%101 = apply %41(%96, %100, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %102, %103
%102 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 0 // user: %105
%103 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 1 // user: %104
cond_fail %103 : $Builtin.Int1 // id: %104
%105 = apply %47(%102, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %106
%106 = tuple_extract %105 : $(Builtin.Word, Builtin.Int1), 0 // user: %110
%107 = apply %47(%100, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %108
%108 = tuple_extract %107 : $(Builtin.Word, Builtin.Int1), 0 // user: %109
%109 = apply %54(%108, %53) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %110
%110 = apply %56(%106, %109) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %111
%111 = apply %70(%110, %69, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %112
%112 = tuple_extract %111 : $(Builtin.Word, Builtin.Int1), 0 // user: %113
%113 = index_raw_pointer %66 : $Builtin.RawPointer, %112 : $Builtin.Word // user: %114
%114 = pointer_to_address %113 : $Builtin.RawPointer to $*Int // user: %115
%115 = index_addr %114 : $*Int, %11 : $Builtin.Word // user: %116
%116 = load %115 : $*Int // user: %117
store %116 to %12#1 : $*Int // id: %117
strong_retain %9 : $@callee_owned (@out Bool, @in Int) -> () // id: %118
%119 = apply %9(%0, %12#1) : $@callee_owned (@out Bool, @in Int) -> ()
dealloc_stack %12#0 : $*@local_storage Int // id: %120
%121 = tuple () // user: %122
return %121 : $() // id: %122
}
// specialization <Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> with Swift.MapCollectionView<Swift.Array<Swift.Int>, Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<Swift.Array<Swift.Int>>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element
sil shared specialization <Swift.MapCollectionView<[Swift.Int], Swift.Bool> with Swift.MapCollectionView<[Swift.Int], Swift.Bool> : Swift.CollectionType, Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> with Swift.MapSequenceGenerator<Swift.IndexingGenerator<[Swift.Int]>, Swift.Bool> : Swift.GeneratorType, Swift.Bool, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Bool> of Swift.LazyForwardCollection.subscript.getter (A.Index) -> A.Generator.Element : $@cc(method) @thin (@out Bool, @in Int, @in LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>) -> () {
bb0(%0 : $*Bool, %1 : $*Int, %2 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>):
%3 = struct_element_addr %2 : $*LazyForwardCollection<MapCollectionView<Array<Int>, Bool>>, #LazyForwardCollection._base // users: %6, %10
%4 = struct_element_addr %1 : $*Int, #Int.value // user: %5
%5 = load %4 : $*Builtin.Word // users: %35, %79, %85, %85, %88, %91, %115
%6 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._base // user: %7
%7 = struct_element_addr %6 : $*Array<Int>, #Array._buffer // user: %8
%8 = struct_element_addr %7 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %9, %121
%9 = load %8 : $*Optional<Builtin.NativeObject> // users: %29, %65
%10 = struct_element_addr %3 : $*MapCollectionView<Array<Int>, Bool>, #MapCollectionView._transform // users: %11, %122
%11 = load %10 : $*@callee_owned (@out Bool, @in Int) -> () // users: %118, %119
%12 = alloc_stack $Int // users: %117, %119, %120
%13 = integer_literal $Builtin.Int1, -1 // users: %22, %27, %31, %42, %63, %82, %86, %92, %95, %101
%14 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %18, %25, %37, %59, %61, %94
%15 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %16
%16 = apply %14<Builtin.NativeObject?>(%15) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %20
%17 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %18
%18 = apply %14<_ContiguousArrayStorage<Int>?>(%17) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %20, %26
%19 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %20, %26, %62
%20 = apply %19(%16, %18) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%21 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %22, %27, %31, %63, %82, %86, %92
%22 = apply %21(%20, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %25
%25 = apply %14<HeapBuffer<_ArrayBody, Int>>(%24) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %26
%26 = apply %19(%18, %25) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %27
%27 = apply %21(%26, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %28
cond_fail %27 : $Builtin.Int1 // id: %28
%29 = unchecked_ref_bit_cast %9 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %30
%30 = enum_is_tag $Builtin.Int1, %29 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %31
%31 = apply %21(%30, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %32
cond_fail %31 : $Builtin.Int1 // id: %32
%33 = integer_literal $Builtin.Word, 0 // user: %35
%34 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %35
%35 = apply %34(%5, %33) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %81
%36 = metatype $@thick HeapObject.Type // user: %37
%37 = apply %14<HeapObject>(%36) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %42
%38 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %40, %100
%39 = metatype $@thick _ArrayBody.Type // users: %40, %94
%40 = apply %38<_ArrayBody>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %42, %51
%41 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %88, %95, %101
%42 = apply %41(%37, %40, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %43, %44
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %49
%44 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 1 // user: %45
cond_fail %44 : $Builtin.Int1 // id: %45
%46 = integer_literal $Builtin.Word, 1 // users: %49, %51, %88, %105, %107
%47 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %49, %51, %105, %107
%48 = integer_literal $Builtin.Int1, 0 // users: %49, %51, %71, %88, %105, %107, %111
%49 = apply %47(%43, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %50
%50 = tuple_extract %49 : $(Builtin.Word, Builtin.Int1), 0 // user: %57
%51 = apply %47(%40, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %52
%52 = tuple_extract %51 : $(Builtin.Word, Builtin.Int1), 0 // user: %55
%53 = integer_literal $Builtin.Word, -1 // users: %55, %109
%54 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %55, %109
%55 = apply %54(%52, %53) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %57
%56 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %57, %110
%57 = apply %56(%50, %55) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %71, %95
%58 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %59
%59 = apply %14<HeapBufferStorage<_ArrayBody, Int>?>(%58) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%60 = metatype $@thick Builtin.NativeObject.Type // user: %61
%61 = apply %14<Builtin.NativeObject>(%60) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%62 = apply %19(%59, %61) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %63
%63 = apply %21(%62, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %64
cond_fail %63 : $Builtin.Int1 // id: %64
%65 = unchecked_ref_bit_cast %9 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %66
%66 = ref_to_raw_pointer %65 : $Builtin.NativeObject to $Builtin.RawPointer // users: %73, %113
%67 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %69
%68 = metatype $@thick Int8.Type // user: %69
%69 = apply %67<Int8>(%68) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %71, %111
%70 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %71, %111
%71 = apply %70(%57, %69, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %72
%72 = tuple_extract %71 : $(Builtin.Word, Builtin.Int1), 0 // user: %73
%73 = index_raw_pointer %66 : $Builtin.RawPointer, %72 : $Builtin.Word // user: %74
%74 = pointer_to_address %73 : $Builtin.RawPointer to $*_ArrayBody // user: %75
%75 = struct_element_addr %74 : $*_ArrayBody, #_ArrayBody.count // user: %76
%76 = struct_element_addr %75 : $*Int, #Int.value // user: %77
%77 = load %76 : $*Builtin.Word // user: %79
%78 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %79
%79 = apply %78(%5, %77) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %81
%80 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %81
%81 = apply %80(%35, %79) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %82
%82 = apply %21(%81, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %83
cond_fail %82 : $Builtin.Int1 // id: %83
%84 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %85
%85 = apply %84(%5, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %86
%86 = apply %21(%85, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %87
cond_fail %86 : $Builtin.Int1 // id: %87
%88 = apply %41(%5, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %89
%89 = tuple_extract %88 : $(Builtin.Word, Builtin.Int1), 0 // user: %91
%90 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %91
%91 = apply %90(%89, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %92
%92 = apply %21(%91, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %93
cond_fail %92 : $Builtin.Int1 // id: %93
%94 = apply %14<_ArrayBody>(%39) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %95
%95 = apply %41(%57, %94, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %96, %97
%96 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 0 // user: %101
%97 = tuple_extract %95 : $(Builtin.Word, Builtin.Int1), 1 // user: %98
cond_fail %97 : $Builtin.Int1 // id: %98
%99 = metatype $@thick Int.Type // user: %100
%100 = apply %38<Int>(%99) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %101, %107
%101 = apply %41(%96, %100, %13) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %102, %103
%102 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 0 // user: %105
%103 = tuple_extract %101 : $(Builtin.Word, Builtin.Int1), 1 // user: %104
cond_fail %103 : $Builtin.Int1 // id: %104
%105 = apply %47(%102, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %106
%106 = tuple_extract %105 : $(Builtin.Word, Builtin.Int1), 0 // user: %110
%107 = apply %47(%100, %46, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %108
%108 = tuple_extract %107 : $(Builtin.Word, Builtin.Int1), 0 // user: %109
%109 = apply %54(%108, %53) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %110
%110 = apply %56(%106, %109) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %111
%111 = apply %70(%110, %69, %48) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %112
%112 = tuple_extract %111 : $(Builtin.Word, Builtin.Int1), 0 // user: %113
%113 = index_raw_pointer %66 : $Builtin.RawPointer, %112 : $Builtin.Word // user: %114
%114 = pointer_to_address %113 : $Builtin.RawPointer to $*Int // user: %115
%115 = index_addr %114 : $*Int, %5 : $Builtin.Word // user: %116
%116 = load %115 : $*Int // user: %117
store %116 to %12#1 : $*Int // id: %117
strong_retain %11 : $@callee_owned (@out Bool, @in Int) -> () // id: %118
%119 = apply %11(%0, %12#1) : $@callee_owned (@out Bool, @in Int) -> ()
dealloc_stack %12#0 : $*@local_storage Int // id: %120
%121 = load %8 : $*Optional<Builtin.NativeObject> // user: %123
%122 = load %10 : $*@callee_owned (@out Bool, @in Int) -> () // user: %124
release_value %121 : $Optional<Builtin.NativeObject> // id: %123
strong_release %122 : $@callee_owned (@out Bool, @in Int) -> () // id: %124
%125 = tuple () // user: %126
return %125 : $() // id: %126
}
// specialization <Swift.Int> of protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.Array : Swift.SequenceType
sil shared specialization <Swift.Int> of protocol witness for Swift.SequenceType.generate <A : Swift.SequenceType>(inout Swift.SequenceType.Self)() -> Swift.SequenceType.Self.Generator in conformance Swift.Array : Swift.SequenceType : $@cc(witness_method) @thin (@out IndexingGenerator<Array<Int>>, @inout Array<Int>) -> () {
bb0(%0 : $*IndexingGenerator<Array<Int>>, %1 : $*Array<Int>):
%2 = load %1 : $*Array<Int> // users: %3, %7
%3 = struct_extract %2 : $Array<Int>, #Array._buffer // user: %4
%4 = struct_extract %3 : $_ArrayBuffer<Int>, #_ArrayBuffer.storage // user: %10
%5 = integer_literal $Builtin.Word, 0 // user: %6
%6 = struct $Int (%5 : $Builtin.Word) // user: %7
%7 = struct $IndexingGenerator<Array<Int>> (%2 : $Array<Int>, %6 : $Int) // user: %8
store %7 to %0 : $*IndexingGenerator<Array<Int>> // id: %8
%9 = tuple () // user: %11
retain_value %4 : $Optional<Builtin.NativeObject> // id: %10
return %9 : $() // id: %11
}
// specialization <Swift.Int> of Swift.Array.generate <A>(Swift.Array<A>)() -> Swift.IndexingGenerator<Swift.Array<A>>
sil shared specialization <Swift.Int> of Swift.Array.generate <A>([A])() -> Swift.IndexingGenerator<[A]> : $@cc(method) @thin (@owned Array<Int>) -> @owned IndexingGenerator<Array<Int>> {
bb0(%0 : $Array<Int>):
%1 = integer_literal $Builtin.Word, 0 // user: %2
%2 = struct $Int (%1 : $Builtin.Word) // user: %3
%3 = struct $IndexingGenerator<Array<Int>> (%0 : $Array<Int>, %2 : $Int) // user: %4
return %3 : $IndexingGenerator<Array<Int>> // id: %4
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A> : $@thin (@out IndexingGenerator<Array<Int>>, @in Array<Int>, @thin IndexingGenerator<Array<Int>>.Type) -> () {
bb0(%0 : $*IndexingGenerator<Array<Int>>, %1 : $*Array<Int>, %2 : $@thin IndexingGenerator<Array<Int>>.Type):
%3 = load %1 : $*Array<Int> // user: %6
%4 = integer_literal $Builtin.Word, 0 // user: %5
%5 = struct $Int (%4 : $Builtin.Word) // user: %6
%6 = struct $IndexingGenerator<Array<Int>> (%3 : $Array<Int>, %5 : $Int) // user: %7
store %6 to %0 : $*IndexingGenerator<Array<Int>> // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of protocol witness for Swift.GeneratorType.next <A : Swift.GeneratorType>(inout Swift.GeneratorType.Self)() -> Swift.Optional<Swift.GeneratorType.Self.Element> in conformance Swift.IndexingGenerator : Swift.GeneratorType
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of protocol witness for Swift.GeneratorType.next <A : Swift.GeneratorType>(inout Swift.GeneratorType.Self)() -> Swift.GeneratorType.Self.Element? in conformance Swift.IndexingGenerator : Swift.GeneratorType : $@cc(witness_method) @thin (@out Optional<Int>, @inout IndexingGenerator<Array<Int>>) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*IndexingGenerator<Array<Int>>):
%2 = struct_element_addr %1 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._position // users: %3, %89
%3 = struct_element_addr %2 : $*Int, #Int.value // users: %4, %82
%4 = load %3 : $*Builtin.Word // users: %71, %74
%5 = struct_element_addr %1 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._elements // user: %6
%6 = struct_element_addr %5 : $*Array<Int>, #Array._buffer // user: %7
%7 = struct_element_addr %6 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %8, %90
%8 = load %7 : $*Optional<Builtin.NativeObject> // users: %20, %26, %58
%9 = integer_literal $Builtin.Int1, -1 // users: %18, %24, %35, %56, %93, %103, %122, %141, %145, %149, %152, %158
%10 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %12, %14, %22, %30, %52, %54, %99, %118, %120, %151
%11 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %12
%12 = apply %10<Builtin.NativeObject?>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %14
%14 = apply %10<_ContiguousArrayStorage<Int>?>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %23
%15 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %16, %23, %55, %71, %74, %121
%16 = apply %15(%12, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
%17 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %18, %24, %56, %93, %122, %141, %145, %149
%18 = apply %17(%16, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Optional<_ContiguousArrayStorage<Int>> // user: %75
%21 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %22
%22 = apply %10<HeapBuffer<_ArrayBody, Int>>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %23
%23 = apply %15(%14, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
%24 = apply %17(%23, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %25
cond_fail %24 : $Builtin.Int1 // id: %25
%26 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %27
%27 = enum_is_tag $Builtin.Int1, %26 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %28
cond_br %27, bb1, bb2 // id: %28
bb1: // Preds: bb0
%29 = metatype $@thick HeapObject.Type // user: %30
%30 = apply %10<HeapObject>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %35
%31 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%32 = metatype $@thick _ArrayBody.Type // user: %33
%33 = apply %31<_ArrayBody>(%32) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %44
%34 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %35
%35 = apply %34(%30, %33, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %36, %37
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %42
%37 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = integer_literal $Builtin.Word, 1 // users: %42, %44
%40 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %44
%41 = integer_literal $Builtin.Int1, 0 // users: %42, %44, %64
%42 = apply %40(%36, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %50
%44 = apply %40(%33, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %45
%45 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%46 = integer_literal $Builtin.Word, -1 // user: %48
%47 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %48
%48 = apply %47(%45, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%49 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%50 = apply %49(%43, %48) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %64
%51 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %52
%52 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%53 = metatype $@thick Builtin.NativeObject.Type // user: %54
%54 = apply %10<Builtin.NativeObject>(%53) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%55 = apply %15(%52, %54) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %56
%56 = apply %17(%55, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %57
cond_fail %56 : $Builtin.Int1 // id: %57
%58 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %59
%59 = ref_to_raw_pointer %58 : $Builtin.NativeObject to $Builtin.RawPointer // user: %66
%60 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%61 = metatype $@thick Int8.Type // user: %62
%62 = apply %60<Int8>(%61) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %64
%63 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %64
%64 = apply %63(%50, %62, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = tuple_extract %64 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%66 = index_raw_pointer %59 : $Builtin.RawPointer, %65 : $Builtin.Word // user: %67
%67 = pointer_to_address %66 : $Builtin.RawPointer to $*_ArrayBody // user: %68
%68 = struct_element_addr %67 : $*_ArrayBody, #_ArrayBody.count // user: %69
%69 = struct_element_addr %68 : $*Int, #Int.value // user: %70
%70 = load %69 : $*Builtin.Word // user: %71
%71 = apply %15(%4, %70) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
cond_br %71, bb3, bb5 // id: %72
bb2: // Preds: bb0
%73 = integer_literal $Builtin.Word, 0 // user: %74
%74 = apply %15(%4, %73) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %76
retain_value %20 : $Optional<_ContiguousArrayStorage<Int>> // id: %75
cond_br %74, bb3, bb5 // id: %76
bb3: // Preds: bb1 bb2
%77 = enum $Optional<Int>, #Optional.None!enumelt // user: %78
store %77 to %0 : $*Optional<Int> // id: %78
br bb4 // id: %79
bb4: // Preds: bb3 bb5
%80 = tuple () // user: %81
return %80 : $() // id: %81
bb5: // Preds: bb1 bb2
%82 = load %3 : $*Builtin.Word // users: %86, %97, %138, %144, %144, %148, %172
%83 = integer_literal $Builtin.Word, 1 // users: %86, %108, %110, %162, %164
%84 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %86, %103, %152, %158
%85 = integer_literal $Builtin.Int1, 0 // users: %86, %108, %110, %130, %162, %164, %168
%86 = apply %84(%82, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %87
%87 = tuple_extract %86 : $(Builtin.Word, Builtin.Int1), 0 // users: %88, %148
%88 = struct $Int (%87 : $Builtin.Word) // user: %89
store %88 to %2 : $*Int // id: %89
%90 = load %7 : $*Optional<Builtin.NativeObject> // users: %91, %124
%91 = unchecked_ref_bit_cast %90 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %92
%92 = enum_is_tag $Builtin.Int1, %91 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %93
%93 = apply %17(%92, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %94
cond_fail %93 : $Builtin.Int1 // id: %94
%95 = integer_literal $Builtin.Word, 0 // user: %97
%96 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
%97 = apply %96(%82, %95) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %140
%98 = metatype $@thick HeapObject.Type // user: %99
%99 = apply %10<HeapObject>(%98) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %103
%100 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %102, %157
%101 = metatype $@thick _ArrayBody.Type // users: %102, %151
%102 = apply %100<_ArrayBody>(%101) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %103, %110
%103 = apply %84(%99, %102, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %104, %105
%104 = tuple_extract %103 : $(Builtin.Word, Builtin.Int1), 0 // user: %108
%105 = tuple_extract %103 : $(Builtin.Word, Builtin.Int1), 1 // user: %106
cond_fail %105 : $Builtin.Int1 // id: %106
%107 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %108, %110, %162, %164
%108 = apply %107(%104, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %109
%109 = tuple_extract %108 : $(Builtin.Word, Builtin.Int1), 0 // user: %116
%110 = apply %107(%102, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %111
%111 = tuple_extract %110 : $(Builtin.Word, Builtin.Int1), 0 // user: %114
%112 = integer_literal $Builtin.Word, -1 // users: %114, %166
%113 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %114, %166
%114 = apply %113(%111, %112) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %116
%115 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %116, %167
%116 = apply %115(%109, %114) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %130, %152
%117 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %118
%118 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%117) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%119 = metatype $@thick Builtin.NativeObject.Type // user: %120
%120 = apply %10<Builtin.NativeObject>(%119) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%121 = apply %15(%118, %120) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %122
%122 = apply %17(%121, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %123
cond_fail %122 : $Builtin.Int1 // id: %123
%124 = unchecked_ref_bit_cast %90 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %125
%125 = ref_to_raw_pointer %124 : $Builtin.NativeObject to $Builtin.RawPointer // users: %132, %170
%126 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %128
%127 = metatype $@thick Int8.Type // user: %128
%128 = apply %126<Int8>(%127) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %130, %168
%129 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %130, %168
%130 = apply %129(%116, %128, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %131
%131 = tuple_extract %130 : $(Builtin.Word, Builtin.Int1), 0 // user: %132
%132 = index_raw_pointer %125 : $Builtin.RawPointer, %131 : $Builtin.Word // user: %133
%133 = pointer_to_address %132 : $Builtin.RawPointer to $*_ArrayBody // user: %134
%134 = struct_element_addr %133 : $*_ArrayBody, #_ArrayBody.count // user: %135
%135 = struct_element_addr %134 : $*Int, #Int.value // user: %136
%136 = load %135 : $*Builtin.Word // user: %138
%137 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %138
%138 = apply %137(%82, %136) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %140
%139 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %140
%140 = apply %139(%97, %138) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %141
%141 = apply %17(%140, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %142
cond_fail %141 : $Builtin.Int1 // id: %142
%143 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %144
%144 = apply %143(%82, %82) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %145
%145 = apply %17(%144, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %146
cond_fail %145 : $Builtin.Int1 // id: %146
%147 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %148
%148 = apply %147(%87, %82) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %149
%149 = apply %17(%148, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %150
cond_fail %149 : $Builtin.Int1 // id: %150
%151 = apply %10<_ArrayBody>(%101) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %152
%152 = apply %84(%116, %151, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %153, %154
%153 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 0 // user: %158
%154 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 1 // user: %155
cond_fail %154 : $Builtin.Int1 // id: %155
%156 = metatype $@thick Int.Type // user: %157
%157 = apply %100<Int>(%156) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %158, %164
%158 = apply %84(%153, %157, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %159, %160
%159 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 0 // user: %162
%160 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 1 // user: %161
cond_fail %160 : $Builtin.Int1 // id: %161
%162 = apply %107(%159, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %163
%163 = tuple_extract %162 : $(Builtin.Word, Builtin.Int1), 0 // user: %167
%164 = apply %107(%157, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %165
%165 = tuple_extract %164 : $(Builtin.Word, Builtin.Int1), 0 // user: %166
%166 = apply %113(%165, %112) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %167
%167 = apply %115(%163, %166) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %168
%168 = apply %129(%167, %128, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %169
%169 = tuple_extract %168 : $(Builtin.Word, Builtin.Int1), 0 // user: %170
%170 = index_raw_pointer %125 : $Builtin.RawPointer, %169 : $Builtin.Word // user: %171
%171 = pointer_to_address %170 : $Builtin.RawPointer to $*Int // user: %172
%172 = index_addr %171 : $*Int, %82 : $Builtin.Word // user: %173
%173 = load %172 : $*Int // user: %174
%174 = enum $Optional<Int>, #Optional.Some!enumelt.1, %173 : $Int // user: %175
store %174 to %0 : $*Optional<Int> // id: %175
br bb4 // id: %176
}
// specialization <Swift.Array<Swift.Int> with Swift.Array<Swift.Int> : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> Swift.Optional<A._Element>
sil shared specialization <[Swift.Int] with [Swift.Int] : Swift._CollectionType, Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int, Swift.Int> of Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> A._Element? : $@cc(method) @thin (@out Optional<Int>, @inout IndexingGenerator<Array<Int>>) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*IndexingGenerator<Array<Int>>):
%2 = struct_element_addr %1 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._position // users: %3, %89
%3 = struct_element_addr %2 : $*Int, #Int.value // users: %4, %82
%4 = load %3 : $*Builtin.Word // users: %71, %74
%5 = struct_element_addr %1 : $*IndexingGenerator<Array<Int>>, #IndexingGenerator._elements // user: %6
%6 = struct_element_addr %5 : $*Array<Int>, #Array._buffer // user: %7
%7 = struct_element_addr %6 : $*_ArrayBuffer<Int>, #_ArrayBuffer.storage // users: %8, %90
%8 = load %7 : $*Optional<Builtin.NativeObject> // users: %20, %26, %58
%9 = integer_literal $Builtin.Int1, -1 // users: %18, %24, %35, %56, %93, %103, %122, %141, %145, %149, %152, %158
%10 = builtin_function_ref "sizeof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %12, %14, %22, %30, %52, %54, %99, %118, %120, %151
%11 = metatype $@thick Optional<Builtin.NativeObject>.Type // user: %12
%12 = apply %10<Builtin.NativeObject?>(%11) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %16
%13 = metatype $@thick Optional<_ContiguousArrayStorage<Int>>.Type // user: %14
%14 = apply %10<_ContiguousArrayStorage<Int>?>(%13) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %16, %23
%15 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %16, %23, %55, %71, %74, %121
%16 = apply %15(%12, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
%17 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %18, %24, %56, %93, %122, %141, %145, %149
%18 = apply %17(%16, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %19
cond_fail %18 : $Builtin.Int1 // id: %19
%20 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Optional<_ContiguousArrayStorage<Int>> // user: %75
%21 = metatype $@thick HeapBuffer<_ArrayBody, Int>.Type // user: %22
%22 = apply %10<HeapBuffer<_ArrayBody, Int>>(%21) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %23
%23 = apply %15(%14, %22) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
%24 = apply %17(%23, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %25
cond_fail %24 : $Builtin.Int1 // id: %25
%26 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %27
%27 = enum_is_tag $Builtin.Int1, %26 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %28
cond_br %27, bb1, bb2 // id: %28
bb1: // Preds: bb0
%29 = metatype $@thick HeapObject.Type // user: %30
%30 = apply %10<HeapObject>(%29) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %35
%31 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %33
%32 = metatype $@thick _ArrayBody.Type // user: %33
%33 = apply %31<_ArrayBody>(%32) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %35, %44
%34 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %35
%35 = apply %34(%30, %33, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %36, %37
%36 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 0 // user: %42
%37 = tuple_extract %35 : $(Builtin.Word, Builtin.Int1), 1 // user: %38
cond_fail %37 : $Builtin.Int1 // id: %38
%39 = integer_literal $Builtin.Word, 1 // users: %42, %44
%40 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %42, %44
%41 = integer_literal $Builtin.Int1, 0 // users: %42, %44, %64
%42 = apply %40(%36, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %43
%43 = tuple_extract %42 : $(Builtin.Word, Builtin.Int1), 0 // user: %50
%44 = apply %40(%33, %39, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %45
%45 = tuple_extract %44 : $(Builtin.Word, Builtin.Int1), 0 // user: %48
%46 = integer_literal $Builtin.Word, -1 // user: %48
%47 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %48
%48 = apply %47(%45, %46) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%49 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %50
%50 = apply %49(%43, %48) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %64
%51 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %52
%52 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%51) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%53 = metatype $@thick Builtin.NativeObject.Type // user: %54
%54 = apply %10<Builtin.NativeObject>(%53) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %55
%55 = apply %15(%52, %54) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %56
%56 = apply %17(%55, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %57
cond_fail %56 : $Builtin.Int1 // id: %57
%58 = unchecked_ref_bit_cast %8 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %59
%59 = ref_to_raw_pointer %58 : $Builtin.NativeObject to $Builtin.RawPointer // user: %66
%60 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %62
%61 = metatype $@thick Int8.Type // user: %62
%62 = apply %60<Int8>(%61) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %64
%63 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %64
%64 = apply %63(%50, %62, %41) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %65
%65 = tuple_extract %64 : $(Builtin.Word, Builtin.Int1), 0 // user: %66
%66 = index_raw_pointer %59 : $Builtin.RawPointer, %65 : $Builtin.Word // user: %67
%67 = pointer_to_address %66 : $Builtin.RawPointer to $*_ArrayBody // user: %68
%68 = struct_element_addr %67 : $*_ArrayBody, #_ArrayBody.count // user: %69
%69 = struct_element_addr %68 : $*Int, #Int.value // user: %70
%70 = load %69 : $*Builtin.Word // user: %71
%71 = apply %15(%4, %70) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %72
cond_br %71, bb3, bb5 // id: %72
bb2: // Preds: bb0
%73 = integer_literal $Builtin.Word, 0 // user: %74
%74 = apply %15(%4, %73) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %76
retain_value %20 : $Optional<_ContiguousArrayStorage<Int>> // id: %75
cond_br %74, bb3, bb5 // id: %76
bb3: // Preds: bb1 bb2
%77 = enum $Optional<Int>, #Optional.None!enumelt // user: %78
store %77 to %0 : $*Optional<Int> // id: %78
br bb4 // id: %79
bb4: // Preds: bb3 bb5
%80 = tuple () // user: %81
return %80 : $() // id: %81
bb5: // Preds: bb1 bb2
%82 = load %3 : $*Builtin.Word // users: %86, %97, %138, %144, %144, %148, %172
%83 = integer_literal $Builtin.Word, 1 // users: %86, %108, %110, %162, %164
%84 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %86, %103, %152, %158
%85 = integer_literal $Builtin.Int1, 0 // users: %86, %108, %110, %130, %162, %164, %168
%86 = apply %84(%82, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %87
%87 = tuple_extract %86 : $(Builtin.Word, Builtin.Int1), 0 // users: %88, %148
%88 = struct $Int (%87 : $Builtin.Word) // user: %89
store %88 to %2 : $*Int // id: %89
%90 = load %7 : $*Optional<Builtin.NativeObject> // users: %91, %124
%91 = unchecked_ref_bit_cast %90 : $Optional<Builtin.NativeObject> to $Optional<HeapBufferStorage<_ArrayBody, Int>> // user: %92
%92 = enum_is_tag $Builtin.Int1, %91 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %93
%93 = apply %17(%92, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %94
cond_fail %93 : $Builtin.Int1 // id: %94
%95 = integer_literal $Builtin.Word, 0 // user: %97
%96 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %97
%97 = apply %96(%82, %95) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %140
%98 = metatype $@thick HeapObject.Type // user: %99
%99 = apply %10<HeapObject>(%98) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %103
%100 = builtin_function_ref "alignof" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %102, %157
%101 = metatype $@thick _ArrayBody.Type // users: %102, %151
%102 = apply %100<_ArrayBody>(%101) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %103, %110
%103 = apply %84(%99, %102, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %104, %105
%104 = tuple_extract %103 : $(Builtin.Word, Builtin.Int1), 0 // user: %108
%105 = tuple_extract %103 : $(Builtin.Word, Builtin.Int1), 1 // user: %106
cond_fail %105 : $Builtin.Int1 // id: %106
%107 = builtin_function_ref "ssub_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %108, %110, %162, %164
%108 = apply %107(%104, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %109
%109 = tuple_extract %108 : $(Builtin.Word, Builtin.Int1), 0 // user: %116
%110 = apply %107(%102, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %111
%111 = tuple_extract %110 : $(Builtin.Word, Builtin.Int1), 0 // user: %114
%112 = integer_literal $Builtin.Word, -1 // users: %114, %166
%113 = builtin_function_ref "xor_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %114, %166
%114 = apply %113(%111, %112) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %116
%115 = builtin_function_ref "and_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %116, %167
%116 = apply %115(%109, %114) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %130, %152
%117 = metatype $@thick Optional<HeapBufferStorage<_ArrayBody, Int>>.Type // user: %118
%118 = apply %10<HeapBufferStorage<_ArrayBody, Int>?>(%117) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%119 = metatype $@thick Builtin.NativeObject.Type // user: %120
%120 = apply %10<Builtin.NativeObject>(%119) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %121
%121 = apply %15(%118, %120) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %122
%122 = apply %17(%121, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %123
cond_fail %122 : $Builtin.Int1 // id: %123
%124 = unchecked_ref_bit_cast %90 : $Optional<Builtin.NativeObject> to $Builtin.NativeObject // user: %125
%125 = ref_to_raw_pointer %124 : $Builtin.NativeObject to $Builtin.RawPointer // users: %132, %170
%126 = builtin_function_ref "strideof_nonzero" : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %128
%127 = metatype $@thick Int8.Type // user: %128
%128 = apply %126<Int8>(%127) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %130, %168
%129 = builtin_function_ref "smul_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %130, %168
%130 = apply %129(%116, %128, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %131
%131 = tuple_extract %130 : $(Builtin.Word, Builtin.Int1), 0 // user: %132
%132 = index_raw_pointer %125 : $Builtin.RawPointer, %131 : $Builtin.Word // user: %133
%133 = pointer_to_address %132 : $Builtin.RawPointer to $*_ArrayBody // user: %134
%134 = struct_element_addr %133 : $*_ArrayBody, #_ArrayBody.count // user: %135
%135 = struct_element_addr %134 : $*Int, #Int.value // user: %136
%136 = load %135 : $*Builtin.Word // user: %138
%137 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %138
%138 = apply %137(%82, %136) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %140
%139 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %140
%140 = apply %139(%97, %138) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %141
%141 = apply %17(%140, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %142
cond_fail %141 : $Builtin.Int1 // id: %142
%143 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %144
%144 = apply %143(%82, %82) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %145
%145 = apply %17(%144, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %146
cond_fail %145 : $Builtin.Int1 // id: %146
%147 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %148
%148 = apply %147(%87, %82) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %149
%149 = apply %17(%148, %9) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %150
cond_fail %149 : $Builtin.Int1 // id: %150
%151 = apply %10<_ArrayBody>(%101) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // user: %152
%152 = apply %84(%116, %151, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %153, %154
%153 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 0 // user: %158
%154 = tuple_extract %152 : $(Builtin.Word, Builtin.Int1), 1 // user: %155
cond_fail %154 : $Builtin.Int1 // id: %155
%156 = metatype $@thick Int.Type // user: %157
%157 = apply %100<Int>(%156) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Builtin.Word // users: %158, %164
%158 = apply %84(%153, %157, %9) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // users: %159, %160
%159 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 0 // user: %162
%160 = tuple_extract %158 : $(Builtin.Word, Builtin.Int1), 1 // user: %161
cond_fail %160 : $Builtin.Int1 // id: %161
%162 = apply %107(%159, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %163
%163 = tuple_extract %162 : $(Builtin.Word, Builtin.Int1), 0 // user: %167
%164 = apply %107(%157, %83, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %165
%165 = tuple_extract %164 : $(Builtin.Word, Builtin.Int1), 0 // user: %166
%166 = apply %113(%165, %112) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %167
%167 = apply %115(%163, %166) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %168
%168 = apply %129(%167, %128, %85) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %169
%169 = tuple_extract %168 : $(Builtin.Word, Builtin.Int1), 0 // user: %170
%170 = index_raw_pointer %125 : $Builtin.RawPointer, %169 : $Builtin.Word // user: %171
%171 = pointer_to_address %170 : $Builtin.RawPointer to $*Int // user: %172
%172 = index_addr %171 : $*Int, %82 : $Builtin.Word // user: %173
%173 = load %172 : $*Int // user: %174
%174 = enum $Optional<Int>, #Optional.Some!enumelt.1, %173 : $Int // user: %175
store %174 to %0 : $*Optional<Int> // id: %175
br bb4 // id: %176
}
// protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.Array : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.startIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.Array : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out Array<T>.Index, @inout Array<T>) -> () {
bb0(%0 : $*Int, %1 : $*Array<T>):
%2 = load %1 : $*Array<T> // users: %3, %7
%3 = struct_extract %2 : $Array<T>, #Array._buffer // user: %4
%4 = struct_extract %3 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %6
// function_ref Swift.Array.startIndex.getter : Swift.Int
%5 = function_ref Swift.Array.startIndex.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %7
retain_value %4 : $Optional<Builtin.NativeObject> // id: %6
%7 = apply %5<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %8
store %7 to %0 : $*Int // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.Array : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.endIndex.getter : Swift._CollectionType.Self.Index in conformance Swift.Array : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out Array<T>.Index, @inout Array<T>) -> () {
bb0(%0 : $*Int, %1 : $*Array<T>):
%2 = load %1 : $*Array<T> // users: %3, %7
%3 = struct_extract %2 : $Array<T>, #Array._buffer // user: %4
%4 = struct_extract %3 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %6
// function_ref Swift.Array.endIndex.getter : Swift.Int
%5 = function_ref Swift.Array.endIndex.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %7
retain_value %4 : $Optional<Builtin.NativeObject> // id: %6
%7 = apply %5<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %8
store %7 to %0 : $*Int // id: %8
%9 = tuple () // user: %10
return %9 : $() // id: %10
}
// protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.Array : Swift._CollectionType
sil public_external protocol witness for Swift._CollectionType.subscript.getter (Swift._CollectionType.Self.Index) -> Swift._CollectionType.Self._Element in conformance Swift.Array : Swift._CollectionType : $@cc(witness_method) @thin <T> (@out Array<T>._Element, @in Array<T>.Index, @inout Array<T>) -> () {
bb0(%0 : $*T, %1 : $*Int, %2 : $*Array<T>):
%3 = load %2 : $*Array<T> // users: %4, %9
%4 = struct_extract %3 : $Array<T>, #Array._buffer // user: %5
%5 = struct_extract %4 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %8
%6 = load %1 : $*Int // user: %9
// function_ref Swift.Array.subscript.getter (Swift.Int) -> A
%7 = function_ref Swift.Array.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned Array<τ_0_0>) -> () // user: %9
retain_value %5 : $Optional<Builtin.NativeObject> // id: %8
%9 = apply %7<T>(%0, %6, %3) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned Array<τ_0_0>) -> () // user: %10
return %9 : $() // id: %10
}
// specialization <Swift.UnsafeMutablePointer<Swift.Int> with Swift.UnsafeMutablePointer<Swift.Int> : Swift._Incrementable> of Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A
sil shared [transparent] specialization <Swift.UnsafeMutablePointer<Swift.Int> with Swift.UnsafeMutablePointer<Swift.Int> : Swift._Incrementable> of Swift.++ postfix <A : Swift._Incrementable>(inout A) -> A : $@thin (@out UnsafeMutablePointer<Int>, @inout UnsafeMutablePointer<Int>) -> () {
bb0(%0 : $*UnsafeMutablePointer<Int>, %1 : $*UnsafeMutablePointer<Int>):
%2 = load %1 : $*UnsafeMutablePointer<Int> // user: %9
%3 = alloc_stack $UnsafeMutablePointer<Int> // users: %5, %6, %8
// function_ref protocol witness for Swift._Incrementable.successor <A : Swift._Incrementable>(inout Swift._Incrementable.Self)() -> Swift._Incrementable.Self in conformance Swift.UnsafeMutablePointer : Swift._Incrementable
%4 = function_ref protocol witness for Swift._Incrementable.successor <A : Swift._Incrementable>(inout Swift._Incrementable.Self)() -> Swift._Incrementable.Self in conformance Swift.UnsafeMutablePointer : Swift._Incrementable : $@cc(witness_method) @thin <τ_0_0> (@out UnsafeMutablePointer<τ_0_0>, @inout UnsafeMutablePointer<τ_0_0>) -> () // user: %5
%5 = apply %4<Int>(%3#1, %1) : $@cc(witness_method) @thin <τ_0_0> (@out UnsafeMutablePointer<τ_0_0>, @inout UnsafeMutablePointer<τ_0_0>) -> ()
%6 = load %3#1 : $*UnsafeMutablePointer<Int> // user: %7
store %6 to %1 : $*UnsafeMutablePointer<Int> // id: %7
dealloc_stack %3#0 : $*@local_storage UnsafeMutablePointer<Int> // id: %8
store %2 to %0 : $*UnsafeMutablePointer<Int> // id: %9
%10 = tuple () // user: %11
return %10 : $() // id: %11
}
// specialization <Swift.Int> of Swift.Optional.Some <A>(Swift.Optional<A>.Type)(A) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.Int> of Swift.Optional.Some <A>(A?.Type)(A) -> A? : $@thin (@out Optional<Int>, @in Int, @thin Optional<Int>.Type) -> () {
bb0(%0 : $*Optional<Int>, %1 : $*Int, %2 : $@thin Optional<Int>.Type):
%3 = load %1 : $*Int // user: %4
%4 = enum $Optional<Int>, #Optional.Some!enumelt.1, %3 : $Int // user: %5
store %4 to %0 : $*Optional<Int> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
sil shared specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin (@in Optional<HeapBufferStorage<_ArrayBody, Int>>, _OptionalNilComparisonType) -> Bool {
bb0(%0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %1 : $_OptionalNilComparisonType):
%2 = load %0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // users: %3, %5
%3 = enum_is_tag $Builtin.Int1, %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.Some!enumelt.1 // user: %4
%4 = struct $Bool (%3 : $Builtin.Int1) // user: %6
release_value %2 : $Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %5
return %4 : $Bool // id: %6
}
// specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.Optional.None <A>(Swift.Optional<A>.Type) -> Swift.Optional<A>
sil shared [transparent] specialization <Swift.HeapBufferStorage<Swift._ArrayBody, Swift.Int>> of Swift.Optional.None <A>(A?.Type) -> A? : $@thin (@out Optional<HeapBufferStorage<_ArrayBody, Int>>, @thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type) -> () {
bb0(%0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>>, %1 : $@thin Optional<HeapBufferStorage<_ArrayBody, Int>>.Type):
%2 = enum $Optional<HeapBufferStorage<_ArrayBody, Int>>, #Optional.None!enumelt // user: %3
store %2 to %0 : $*Optional<HeapBufferStorage<_ArrayBody, Int>> // id: %3
%4 = tuple () // user: %5
return %4 : $() // id: %5
}
// protocol witness for Swift._SignedIntegerType.toIntMax <A : Swift._SignedIntegerType>(inout Swift._SignedIntegerType.Self)() -> Swift.Int64 in conformance Swift.Int : Swift._SignedIntegerType
sil public_external protocol witness for Swift._SignedIntegerType.toIntMax <A : Swift._SignedIntegerType>(inout Swift._SignedIntegerType.Self)() -> Swift.Int64 in conformance Swift.Int : Swift._SignedIntegerType : $@cc(witness_method) @thin (@inout Int) -> Int64 {
bb0(%0 : $*Int):
%1 = struct_element_addr %0 : $*Int, #Int.value // user: %2
%2 = load %1 : $*Builtin.Word // user: %4
%3 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // user: %4
%4 = apply %3(%2) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %5
%5 = struct $Int64 (%4 : $Builtin.Int64) // user: %6
return %5 : $Int64 // id: %6
}
// protocol witness for Swift._SignedIntegerType.init <A : Swift._SignedIntegerType>(Swift._SignedIntegerType.Self.Type)(Swift.Int64) -> Swift._SignedIntegerType.Self in conformance Swift.Int : Swift._SignedIntegerType
sil public_external protocol witness for Swift._SignedIntegerType.init <A : Swift._SignedIntegerType>(Swift._SignedIntegerType.Self.Type)(Swift.Int64) -> Swift._SignedIntegerType.Self in conformance Swift.Int : Swift._SignedIntegerType : $@cc(witness_method) @thin (@out Int, Int64, @thick Int.Type) -> () {
bb0(%0 : $*Int, %1 : $Int64, %2 : $@thick Int.Type):
%3 = struct_extract %1 : $Int64, #Int64.value // user: %5
%4 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %5
%5 = apply %4(%3) : $@thin (Builtin.Int64) -> Builtin.Word // user: %6
%6 = struct $Int (%5 : $Builtin.Word) // user: %7
store %6 to %0 : $*Int // id: %7
%8 = tuple () // user: %9
return %8 : $() // id: %9
}
// Swift.UnsafeBufferPointer.startIndex.getter : Swift.Int
sil public_external Swift.UnsafeBufferPointer.startIndex.getter : Swift.Int : $@cc(method) @thin <T> (UnsafeBufferPointer<T>) -> Int {
bb0(%0 : $UnsafeBufferPointer<T>):
%1 = integer_literal $Builtin.Word, 0 // user: %2
%2 = struct $Int (%1 : $Builtin.Word) // user: %3
return %2 : $Int // id: %3
}
// protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.UnsafeBufferPointer : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.UnsafeBufferPointer : Swift.CollectionType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>.Generator.Element, @in UnsafeBufferPointer<T>.Index, @inout UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*T, %1 : $*Int, %2 : $*UnsafeBufferPointer<T>):
%3 = load %2 : $*UnsafeBufferPointer<T> // user: %6
%4 = load %1 : $*Int // user: %6
// function_ref Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A
%5 = function_ref Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeBufferPointer<τ_0_0>) -> () // user: %6
%6 = apply %5<T>(%0, %4, %3) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafeBufferPointer<τ_0_0>) -> () // user: %7
return %6 : $() // id: %7
}
// protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.UnsafeBufferPointer : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.UnsafeBufferPointer : Swift.CollectionType : $@cc(witness_method) @thin <T> (@out UnsafeBufferPointer<T>.Index.Distance, @in UnsafeBufferPointer<T>, _CountElements, @thick UnsafeBufferPointer<T>.Type) -> () {
bb0(%0 : $*Int, %1 : $*UnsafeBufferPointer<T>, %2 : $_CountElements, %3 : $@thick UnsafeBufferPointer<T>.Type):
%4 = load %1 : $*UnsafeBufferPointer<T> // user: %6
%5 = alloc_stack $UnsafeBufferPointer<T> // users: %6, %9, %14
store %4 to %5#1 : $*UnsafeBufferPointer<T> // id: %6
%7 = alloc_stack $Int // users: %9, %10, %13
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
%8 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %9
%9 = apply %8<UnsafeBufferPointer<T>, Int, Int, Int, Int, T>(%7#1, %5#1, %2) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> ()
%10 = load %7#1 : $*Int // user: %11
store %10 to %0 : $*Int // id: %11
%12 = tuple () // user: %15
dealloc_stack %7#0 : $*@local_storage Int // id: %13
dealloc_stack %5#0 : $*@local_storage UnsafeBufferPointer<T> // id: %14
return %12 : $() // id: %15
}
// Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A
sil public_external Swift.UnsafeBufferPointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, UnsafeBufferPointer<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $UnsafeBufferPointer<T>):
%3 = struct_extract %2 : $UnsafeBufferPointer<T>, #UnsafeBufferPointer._position // user: %5
// function_ref Swift.UnsafePointer.subscript.getter (Swift.Int) -> A
%4 = function_ref Swift.UnsafePointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafePointer<τ_0_0>) -> () // user: %5
%5 = apply [transparent] %4<T>(%0, %1, %3) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, UnsafePointer<τ_0_0>) -> ()
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift.UnsafeBufferPointer.endIndex.getter : Swift.Int
sil public_external Swift.UnsafeBufferPointer.endIndex.getter : Swift.Int : $@cc(method) @thin <T> (UnsafeBufferPointer<T>) -> Int {
bb0(%0 : $UnsafeBufferPointer<T>):
// function_ref Swift.- infix <A>(Swift.UnsafePointer<A>, Swift.UnsafePointer<A>) -> Swift.Int
%1 = function_ref Swift.- infix <A>(Swift.UnsafePointer<A>, Swift.UnsafePointer<A>) -> Swift.Int : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, UnsafePointer<τ_0_0>) -> Int // user: %4
%2 = struct_extract %0 : $UnsafeBufferPointer<T>, #UnsafeBufferPointer._end // user: %4
%3 = struct_extract %0 : $UnsafeBufferPointer<T>, #UnsafeBufferPointer._position // user: %4
%4 = apply [transparent] %1<T>(%2, %3) : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, UnsafePointer<τ_0_0>) -> Int // user: %5
return %4 : $Int // id: %5
}
// Swift.UnsafePointer.subscript.getter (Swift.Int) -> A
sil public_external [transparent] Swift.UnsafePointer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, UnsafePointer<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $UnsafePointer<T>):
// function_ref Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A>
%3 = function_ref Swift.+ infix <A>(Swift.UnsafePointer<A>, Swift.Int) -> Swift.UnsafePointer<A> : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int) -> UnsafePointer<τ_0_0> // user: %4
%4 = apply [transparent] %3<T>(%2, %1) : $@thin <τ_0_0> (UnsafePointer<τ_0_0>, Int) -> UnsafePointer<τ_0_0> // user: %6
// function_ref Swift.UnsafePointer.memory.getter : A
%5 = function_ref Swift.UnsafePointer.memory.getter : A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafePointer<τ_0_0>) -> () // user: %6
%6 = apply [transparent] %5<T>(%0, %4) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, UnsafePointer<τ_0_0>) -> ()
%7 = tuple () // user: %8
return %7 : $() // id: %8
}
// Swift.- infix <A>(Swift.UnsafePointer<A>, Swift.UnsafePointer<A>) -> Swift.Int
sil public_external [transparent] Swift.- infix <A>(Swift.UnsafePointer<A>, Swift.UnsafePointer<A>) -> Swift.Int : $@thin <T> (UnsafePointer<T>, UnsafePointer<T>) -> Int {
bb0(%0 : $UnsafePointer<T>, %1 : $UnsafePointer<T>):
%2 = builtin_function_ref "sub_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %8
%3 = builtin_function_ref "ptrtoint_Word" : $@thin (Builtin.RawPointer) -> Builtin.Word // users: %5, %7
%4 = struct_extract %0 : $UnsafePointer<T>, #UnsafePointer.value // user: %5
%5 = apply %3(%4) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %8
%6 = struct_extract %1 : $UnsafePointer<T>, #UnsafePointer.value // user: %7
%7 = apply %3(%6) : $@thin (Builtin.RawPointer) -> Builtin.Word // user: %8
%8 = apply %2(%5, %7) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // users: %18, %25
// function_ref Swift.strideof <A>(A.Type) -> Swift.Int
%9 = function_ref Swift.strideof <A>(A.Type) -> Swift.Int : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %11
%10 = metatype $@thick T.Type // user: %11
%11 = apply [transparent] %9<T>(%10) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Int // user: %14
%12 = integer_literal $Builtin.Word, 0 // user: %15
%13 = builtin_function_ref "cmp_eq_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %15, %18, %20
%14 = struct_extract %11 : $Int, #Int.value // users: %15, %20, %25
%15 = apply %13(%14, %12) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %16
cond_fail %15 : $Builtin.Int1 // id: %16
%17 = integer_literal $Builtin.Word, -9223372036854775808 // user: %18
%18 = apply %13(%8, %17) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%19 = integer_literal $Builtin.Word, -1 // user: %20
%20 = apply %13(%14, %19) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%21 = builtin_function_ref "and_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %22
%22 = apply %21(%18, %20) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %23
cond_fail %22 : $Builtin.Int1 // id: %23
%24 = builtin_function_ref "sdiv_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %25
%25 = apply %24(%8, %14) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Word // user: %26
%26 = struct $Int (%25 : $Builtin.Word) // user: %27
return %26 : $Int // id: %27
}
// Swift.UnsafePointer.memory.getter : A
sil public_external [transparent] Swift.UnsafePointer.memory.getter : A : $@cc(method) @thin <T> (@out T, UnsafePointer<T>) -> () {
bb0(%0 : $*T, %1 : $UnsafePointer<T>):
%2 = struct_extract %1 : $UnsafePointer<T>, #UnsafePointer.value // user: %3
%3 = pointer_to_address %2 : $Builtin.RawPointer to $*T // user: %4
copy_addr %3 to [initialization] %0 : $*T // id: %4
%5 = tuple () // user: %6
return %5 : $() // id: %6
}
// protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Distance, Swift.ForwardIndexType.Self)) -> Swift.ForwardIndexType.Self.Distance in conformance Swift.Int : Swift.ForwardIndexType
sil public_external protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Distance, Swift.ForwardIndexType.Self)) -> Swift.ForwardIndexType.Self.Distance in conformance Swift.Int : Swift.ForwardIndexType : $@cc(witness_method) @thin (@out Int, @in Int, _Distance, @in Int, @thick Int.Type) -> () {
bb0(%0 : $*Int, %1 : $*Int, %2 : $_Distance, %3 : $*Int, %4 : $@thick Int.Type):
%5 = struct_element_addr %1 : $*Int, #Int.value // user: %6
%6 = load %5 : $*Builtin.Word // user: %11
%7 = struct_element_addr %3 : $*Int, #Int.value // user: %8
%8 = load %7 : $*Builtin.Word // user: %10
%9 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // users: %10, %11
%10 = apply %9(%8) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %14
%11 = apply %9(%6) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %14
%12 = builtin_function_ref "ssub_with_overflow_Int64" : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %14
%13 = integer_literal $Builtin.Int1, 0 // user: %14
%14 = apply %12(%10, %11, %13) : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %15
%15 = tuple_extract %14 : $(Builtin.Int64, Builtin.Int1), 0 // user: %17
%16 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %17
%17 = apply %16(%15) : $@thin (Builtin.Int64) -> Builtin.Word // user: %18
%18 = struct $Int (%17 : $Builtin.Word) // user: %19
store %18 to %0 : $*Int // id: %19
%20 = tuple () // user: %21
return %20 : $() // id: %21
}
// protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Advance, Swift.ForwardIndexType.Self.Distance)) -> Swift.ForwardIndexType.Self in conformance Swift.Int : Swift.ForwardIndexType
sil public_external protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Advance, Swift.ForwardIndexType.Self.Distance)) -> Swift.ForwardIndexType.Self in conformance Swift.Int : Swift.ForwardIndexType : $@cc(witness_method) @thin (@out Int, @in Int, _Advance, @in Int, @thick Int.Type) -> () {
bb0(%0 : $*Int, %1 : $*Int, %2 : $_Advance, %3 : $*Int, %4 : $@thick Int.Type):
%5 = struct_element_addr %1 : $*Int, #Int.value // user: %6
%6 = load %5 : $*Builtin.Word // user: %10
%7 = struct_element_addr %3 : $*Int, #Int.value // user: %8
%8 = load %7 : $*Builtin.Word // user: %11
%9 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // users: %10, %11
%10 = apply %9(%6) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %14
%11 = apply %9(%8) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %14
%12 = builtin_function_ref "sadd_with_overflow_Int64" : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %14
%13 = integer_literal $Builtin.Int1, 0 // user: %14
%14 = apply %12(%10, %11, %13) : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %15
%15 = tuple_extract %14 : $(Builtin.Int64, Builtin.Int1), 0 // user: %17
%16 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // user: %17
%17 = apply %16(%15) : $@thin (Builtin.Int64) -> Builtin.Word // user: %18
%18 = struct $Int (%17 : $Builtin.Word) // user: %19
store %18 to %0 : $*Int // id: %19
%20 = tuple () // user: %21
return %20 : $() // id: %21
}
// protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Advance, (Swift.ForwardIndexType.Self.Distance, Swift.ForwardIndexType.Self))) -> Swift.ForwardIndexType.Self in conformance Swift.Int : Swift.ForwardIndexType
sil public_external protocol witness for Swift.ForwardIndexType.~> infix <A : Swift.ForwardIndexType>(Swift.ForwardIndexType.Self.Type)(Swift.ForwardIndexType.Self, (Swift._Advance, (Swift.ForwardIndexType.Self.Distance, Swift.ForwardIndexType.Self))) -> Swift.ForwardIndexType.Self in conformance Swift.Int : Swift.ForwardIndexType : $@cc(witness_method) @thin (@out Int, @in Int, _Advance, @in Int, @in Int, @thick Int.Type) -> () {
bb0(%0 : $*Int, %1 : $*Int, %2 : $_Advance, %3 : $*Int, %4 : $*Int, %5 : $@thick Int.Type):
%6 = struct_element_addr %1 : $*Int, #Int.value // user: %7
%7 = load %6 : $*Builtin.Word // user: %14
%8 = struct_element_addr %3 : $*Int, #Int.value // user: %9
%9 = load %8 : $*Builtin.Word // users: %23, %31, %33, %45
%10 = struct_element_addr %4 : $*Int, #Int.value // user: %11
%11 = load %10 : $*Builtin.Word // users: %13, %39, %47
%12 = builtin_function_ref "zextOrBitCast_Word_Int64" : $@thin (Builtin.Word) -> Builtin.Int64 // users: %13, %14, %33
%13 = apply %12(%11) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %17
%14 = apply %12(%7) : $@thin (Builtin.Word) -> Builtin.Int64 // users: %17, %35
%15 = builtin_function_ref "ssub_with_overflow_Int64" : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %17
%16 = integer_literal $Builtin.Int1, 0 // users: %17, %35
%17 = apply %15(%13, %14, %16) : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %18
%18 = tuple_extract %17 : $(Builtin.Int64, Builtin.Int1), 0 // user: %20
%19 = builtin_function_ref "truncOrBitCast_Int64_Word" : $@thin (Builtin.Int64) -> Builtin.Word // users: %20, %37
%20 = apply %19(%18) : $@thin (Builtin.Int64) -> Builtin.Word // users: %25, %28, %31, %45
%21 = integer_literal $Builtin.Word, 0 // users: %23, %25, %28
%22 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // users: %23, %25, %45
%23 = apply %22(%9, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %24
cond_br %23, bb1, bb2 // id: %24
bb1: // Preds: bb0
%25 = apply %22(%20, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %26
cond_br %25, bb3, bb4 // id: %26
bb2: // Preds: bb0
%27 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %28
%28 = apply %27(%20, %21) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %29
cond_br %28, bb7, bb4 // id: %29
bb3: // Preds: bb1
%30 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %31
%31 = apply %30(%20, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %32
cond_br %31, bb5, bb4 // id: %32
bb4: // Preds: bb1 bb2 bb3 bb7
%33 = apply %12(%9) : $@thin (Builtin.Word) -> Builtin.Int64 // user: %35
%34 = builtin_function_ref "sadd_with_overflow_Int64" : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %35
%35 = apply %34(%14, %33, %16) : $@thin (Builtin.Int64, Builtin.Int64, Builtin.Int1) -> (Builtin.Int64, Builtin.Int1) // user: %36
%36 = tuple_extract %35 : $(Builtin.Int64, Builtin.Int1), 0 // user: %37
%37 = apply %19(%36) : $@thin (Builtin.Int64) -> Builtin.Word // user: %38
br bb6(%37 : $Builtin.Word) // id: %38
bb5: // Preds: bb3
br bb6(%11 : $Builtin.Word) // id: %39
bb6(%40 : $Builtin.Word): // Preds: bb4 bb5 bb8
%41 = struct $Int (%40 : $Builtin.Word) // user: %42
store %41 to %0 : $*Int // id: %42
%43 = tuple () // user: %44
return %43 : $() // id: %44
bb7: // Preds: bb2
%45 = apply %22(%20, %9) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %46
cond_br %45, bb8, bb4 // id: %46
bb8: // Preds: bb7
br bb6(%11 : $Builtin.Word) // id: %47
}
// Swift.MapCollectionView.startIndex.getter : A.Index
sil public_external Swift.MapCollectionView.startIndex.getter : A.Index : $@cc(method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Base.Index, @in MapCollectionView<Base, T>) -> () {
bb0(%0 : $*Base.Index, %1 : $*MapCollectionView<Base, T>):
%2 = struct_element_addr %1 : $*MapCollectionView<Base, T>, #MapCollectionView._base // user: %4
%3 = witness_method $Base, #_CollectionType.startIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %4
%4 = apply %3<Base, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
destroy_addr %1 : $*MapCollectionView<Base, T> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift.MapCollectionView.endIndex.getter : A.Index
sil public_external Swift.MapCollectionView.endIndex.getter : A.Index : $@cc(method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Base.Index, @in MapCollectionView<Base, T>) -> () {
bb0(%0 : $*Base.Index, %1 : $*MapCollectionView<Base, T>):
%2 = struct_element_addr %1 : $*MapCollectionView<Base, T>, #MapCollectionView._base // user: %4
%3 = witness_method $Base, #_CollectionType.endIndex!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> () // user: %4
%4 = apply %3<Base, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %2) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index, @inout τ_0_0) -> ()
destroy_addr %1 : $*MapCollectionView<Base, T> // id: %5
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift.MapCollectionView.subscript.getter (A.Index) -> B
sil public_external Swift.MapCollectionView.subscript.getter (A.Index) -> B : $@cc(method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out T, @in Base.Index, @in MapCollectionView<Base, T>) -> () {
bb0(%0 : $*T, %1 : $*Base.Index, %2 : $*MapCollectionView<Base, T>):
%3 = struct_element_addr %2 : $*MapCollectionView<Base, T>, #MapCollectionView._transform // user: %4
%4 = load %3 : $*@callee_owned (@out T, @in Base.Generator.Element) -> () // users: %10, %12
%5 = alloc_stack $Base.Generator.Element // users: %11, %12, %14
%6 = struct_element_addr %2 : $*MapCollectionView<Base, T>, #MapCollectionView._base // user: %11
%7 = alloc_stack $Base.Index // users: %8, %11, %13
copy_addr %1 to [initialization] %7#1 : $*Base.Index // id: %8
%9 = witness_method $Base, #CollectionType.subscript!getter.1 : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> () // user: %11
strong_retain %4 : $@callee_owned (@out T, @in Base.Generator.Element) -> () // id: %10
%11 = apply %9<Base, Base.Generator, Base.Generator.Element, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%5#1, %7#1, %6) : $@cc(witness_method) @thin <τ_0_0 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Generator.Element, @in τ_0_0.Index, @inout τ_0_0) -> ()
%12 = apply %4(%0, %5#1) : $@callee_owned (@out T, @in Base.Generator.Element) -> ()
dealloc_stack %7#0 : $*@local_storage Base.Index // id: %13
dealloc_stack %5#0 : $*@local_storage Base.Generator.Element // id: %14
destroy_addr %2 : $*MapCollectionView<Base, T> // id: %15
destroy_addr %1 : $*Base.Index // id: %16
%17 = tuple () // user: %18
return %17 : $() // id: %18
}
// protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.MapCollectionView : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.subscript.getter (Swift.CollectionType.Self.Index) -> Swift.CollectionType.Self.Generator.Element in conformance Swift.MapCollectionView : Swift.CollectionType : $@cc(witness_method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>.Generator.Element, @in MapCollectionView<Base, T>.Index, @inout MapCollectionView<Base, T>) -> () {
bb0(%0 : $*T, %1 : $*Base.Index, %2 : $*MapCollectionView<Base, T>):
%3 = alloc_stack $MapCollectionView<Base, T> // users: %4, %6, %7
copy_addr %2 to [initialization] %3#1 : $*MapCollectionView<Base, T> // id: %4
// function_ref Swift.MapCollectionView.subscript.getter (A.Index) -> B
%5 = function_ref Swift.MapCollectionView.subscript.getter (A.Index) -> B : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %6
%6 = apply %5<Base, T, Base.Generator, Base.Generator.Element, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, Base._Element>(%0, %1, %3#1) : $@cc(method) @thin <τ_0_0, τ_0_1 where τ_0_0 : CollectionType, τ_0_0.Generator : GeneratorType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_1, @in τ_0_0.Index, @in MapCollectionView<τ_0_0, τ_0_1>) -> () // user: %8
dealloc_stack %3#0 : $*@local_storage MapCollectionView<Base, T> // id: %7
return %6 : $() // id: %8
}
// protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.MapCollectionView : Swift.CollectionType
sil public_external protocol witness for Swift.CollectionType.~> infix <A : Swift.CollectionType>(Swift.CollectionType.Self.Type)(Swift.CollectionType.Self, (Swift._CountElements, ())) -> Swift.CollectionType.Self.Index.Distance in conformance Swift.MapCollectionView : Swift.CollectionType : $@cc(witness_method) @thin <Base, T where Base : CollectionType, Base.Generator : GeneratorType, Base.Index : ForwardIndexType, Base.Index.Distance : _SignedIntegerType, Base.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out MapCollectionView<Base, T>.Index.Distance, @in MapCollectionView<Base, T>, _CountElements, @thick MapCollectionView<Base, T>.Type) -> () {
bb0(%0 : $*Base.Index.Distance, %1 : $*MapCollectionView<Base, T>, %2 : $_CountElements, %3 : $@thick MapCollectionView<Base, T>.Type):
// function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance
%4 = function_ref Swift.~> infix <A : Swift._CollectionType>(A, (Swift._CountElements, ())) -> A.Index.Distance : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %5
%5 = apply %4<MapCollectionView<Base, T>, Base.Index, Base.Index.Distance, Base.Index.Distance.IntegerLiteralType, Base.Index._DisabledRangeIndex, T>(%0, %1, %2) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out τ_0_0.Index.Distance, @in τ_0_0, _CountElements) -> () // user: %6
return %5 : $() // id: %6
}
// Swift.Array.startIndex.getter : Swift.Int
sil public_external Swift.Array.startIndex.getter : Swift.Int : $@cc(method) @thin <T> (@owned Array<T>) -> Int {
bb0(%0 : $Array<T>):
%1 = integer_literal $Builtin.Word, 0 // user: %2
%2 = struct $Int (%1 : $Builtin.Word) // user: %6
%3 = struct_extract %0 : $Array<T>, #Array._buffer // user: %4
%4 = struct_extract %3 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %5
release_value %4 : $Optional<Builtin.NativeObject> // id: %5
return %2 : $Int // id: %6
}
// Swift.Array.endIndex.getter : Swift.Int
sil public_external Swift.Array.endIndex.getter : Swift.Int : $@cc(method) @thin <T> (@owned Array<T>) -> Int {
bb0(%0 : $Array<T>):
// function_ref Swift.Array._getCount <A>(Swift.Array<A>)() -> Swift.Int
%1 = function_ref Swift.Array._getCount <A>([A])() -> Swift.Int : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %2
%2 = apply %1<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned Array<τ_0_0>) -> Int // user: %3
return %2 : $Int // id: %3
}
// Swift.Array.subscript.getter (Swift.Int) -> A
sil public_external Swift.Array.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, @owned Array<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $Array<T>):
// function_ref Swift.Array._checkSubscript <A>(Swift.Array<A>)(Swift.Int) -> ()
%3 = function_ref Swift.Array._checkSubscript <A>([A])(Swift.Int) -> () : $@cc(method) @thin <τ_0_0> (Int, @owned Array<τ_0_0>) -> () // user: %7
%4 = struct_extract %2 : $Array<T>, #Array._buffer // user: %5
%5 = struct_extract %4 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %6
retain_value %5 : $Optional<Builtin.NativeObject> // id: %6
%7 = apply %3<T>(%1, %2) : $@cc(method) @thin <τ_0_0> (Int, @owned Array<τ_0_0>) -> ()
// function_ref Swift.Array._getElement <A>(Swift.Array<A>)(Swift.Int) -> A
%8 = function_ref Swift.Array._getElement <A>([A])(Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned Array<τ_0_0>) -> () // user: %9
%9 = apply %8<T>(%0, %1, %2) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned Array<τ_0_0>) -> ()
%10 = tuple () // user: %11
return %10 : $() // id: %11
}
// Swift.Array._checkSubscript <A>(Swift.Array<A>)(Swift.Int) -> ()
sil public_external [semantics "array.check_subscript"] Swift.Array._checkSubscript <A>([A])(Swift.Int) -> () : $@cc(method) @thin <T> (Int, @owned Array<T>) -> () {
bb0(%0 : $Int, %1 : $Array<T>):
%2 = struct_extract %1 : $Array<T>, #Array._buffer // user: %5
%3 = integer_literal $Builtin.Int1, -1 // user: %8
// function_ref Swift._ArrayBuffer._isValidSubscript <A>(Swift._ArrayBuffer<A>)(Swift.Int) -> Swift.Bool
%4 = function_ref Swift._ArrayBuffer._isValidSubscript <A>(Swift._ArrayBuffer<A>)(Swift.Int) -> Swift.Bool : $@cc(method) @thin <τ_0_0> (Int, @owned _ArrayBuffer<τ_0_0>) -> Bool // user: %5
%5 = apply %4<T>(%0, %2) : $@cc(method) @thin <τ_0_0> (Int, @owned _ArrayBuffer<τ_0_0>) -> Bool // user: %7
%6 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %8
%7 = struct_extract %5 : $Bool, #Bool.value // user: %8
%8 = apply %6(%7, %3) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
cond_fail %8 : $Builtin.Int1 // id: %9
%10 = tuple () // user: %11
return %10 : $() // id: %11
}
// Swift.Array._getElement <A>(Swift.Array<A>)(Swift.Int) -> A
sil public_external [semantics "array.get_element"] Swift.Array._getElement <A>([A])(Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, @owned Array<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $Array<T>):
%3 = struct_extract %2 : $Array<T>, #Array._buffer // user: %5
// function_ref Swift._ArrayBuffer.subscript.getter (Swift.Int) -> A
%4 = function_ref Swift._ArrayBuffer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ArrayBuffer<τ_0_0>) -> () // user: %5
%5 = apply %4<T>(%0, %1, %3) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ArrayBuffer<τ_0_0>) -> ()
%6 = tuple () // user: %7
return %6 : $() // id: %7
}
// Swift._ArrayBuffer._isValidSubscript <A>(Swift._ArrayBuffer<A>)(Swift.Int) -> Swift.Bool
sil public_external Swift._ArrayBuffer._isValidSubscript <A>(Swift._ArrayBuffer<A>)(Swift.Int) -> Swift.Bool : $@cc(method) @thin <T> (Int, @owned _ArrayBuffer<T>) -> Bool {
bb0(%0 : $Int, %1 : $_ArrayBuffer<T>):
%2 = struct_extract %1 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // users: %4, %13, %25, %30, %33, %46
// function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool
%3 = function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %5
retain_value %2 : $Optional<Builtin.NativeObject> // id: %4
%5 = apply %3<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %6
%6 = struct_extract %5 : $Bool, #Bool.value // user: %9
%7 = integer_literal $Builtin.Int1, -1 // user: %9
%8 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %9
%9 = apply %8(%6, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %10
cond_br %9, bb1, bb2 // id: %10
bb1: // Preds: bb0
// function_ref Swift._ContiguousArrayBuffer._isValidSubscript <A>(Swift._ContiguousArrayBuffer<A>)(Swift.Int) -> Swift.Bool
%11 = function_ref Swift._ContiguousArrayBuffer._isValidSubscript <A>(Swift._ContiguousArrayBuffer<A>)(Swift.Int) -> Swift.Bool : $@cc(method) @thin <τ_0_0> (Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> Bool // user: %15
// function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A>
%12 = function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A> : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %14
retain_value %2 : $Optional<Builtin.NativeObject> // id: %13
%14 = apply %12<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %15
%15 = apply %11<T>(%0, %14) : $@cc(method) @thin <τ_0_0> (Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> Bool // user: %16
br bb3(%15 : $Bool) // id: %16
bb2: // Preds: bb0
%17 = alloc_stack $Bool // users: %23, %26, %47
%18 = integer_literal $Builtin.Word, 0 // user: %21
%19 = builtin_function_ref "cmp_sge_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %21
%20 = struct_extract %0 : $Int, #Int.value // users: %21, %37
%21 = apply %19(%20, %18) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %22
%22 = struct $Bool (%21 : $Builtin.Int1) // user: %23
store %22 to %17#1 : $*Bool // id: %23
// function_ref protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType
%24 = function_ref protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType : $@cc(witness_method) @thin (@inout Bool) -> Bool // user: %26
retain_value %2 : $Optional<Builtin.NativeObject> // id: %25
%26 = apply %24(%17#1) : $@cc(witness_method) @thin (@inout Bool) -> Bool // user: %27
%27 = struct_extract %26 : $Bool, #Bool.value // user: %28
cond_br %27, bb4, bb5 // id: %28
bb3(%29 : $Bool): // Preds: bb1 bb6
release_value %2 : $Optional<Builtin.NativeObject> // id: %30
return %29 : $Bool // id: %31
bb4: // Preds: bb2
// function_ref Swift._ArrayBuffer.count.getter : Swift.Int
%32 = function_ref Swift._ArrayBuffer.count.getter : Swift.Int : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Int // user: %34
retain_value %2 : $Optional<Builtin.NativeObject> // id: %33
%34 = apply %32<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Int // user: %36
%35 = builtin_function_ref "cmp_slt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %37
%36 = struct_extract %34 : $Int, #Int.value // user: %37
%37 = apply %35(%20, %36) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %38
%38 = struct $Bool (%37 : $Builtin.Int1) // user: %40
// function_ref Swift.Bool.boolValue.getter : Swift.Bool
%39 = function_ref Swift.Bool.boolValue.getter : Swift.Bool : $@cc(method) @thin (Bool) -> Bool // user: %40
%40 = apply %39(%38) : $@cc(method) @thin (Bool) -> Bool // user: %41
br bb6(%40 : $Bool) // id: %41
bb5: // Preds: bb2
%42 = integer_literal $Builtin.Int1, 0 // user: %43
%43 = struct $Bool (%42 : $Builtin.Int1) // user: %44
br bb6(%43 : $Bool) // id: %44
bb6(%45 : $Bool): // Preds: bb4 bb5
release_value %2 : $Optional<Builtin.NativeObject> // id: %46
dealloc_stack %17#0 : $*@local_storage Bool // id: %47
br bb3(%45 : $Bool) // id: %48
}
// Swift._ArrayBuffer.subscript.getter (Swift.Int) -> A
sil public_external Swift._ArrayBuffer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <T> (@out T, Int, @owned _ArrayBuffer<T>) -> () {
bb0(%0 : $*T, %1 : $Int, %2 : $_ArrayBuffer<T>):
// function_ref Swift._ArrayBuffer._typeCheck <A>(Swift._ArrayBuffer<A>)(Swift.Range<Swift.Int>) -> ()
%3 = function_ref Swift._ArrayBuffer._typeCheck <A>(Swift._ArrayBuffer<A>)(Swift.Range<Swift.Int>) -> () : $@cc(method) @thin <τ_0_0> (Range<Int>, @owned _ArrayBuffer<τ_0_0>) -> () // user: %24
%4 = struct_extract %2 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // users: %23, %26, %33, %41, %44
%5 = struct_extract %1 : $Int, #Int.value // users: %9, %9, %15, %18
%6 = integer_literal $Builtin.Int1, 0 // user: %15
%7 = integer_literal $Builtin.Int1, -1 // users: %11, %19, %30, %58
%8 = builtin_function_ref "cmp_sle_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %9
%9 = apply %8(%5, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %11
%10 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %11, %19
%11 = apply %10(%9, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %12
cond_fail %11 : $Builtin.Int1 // id: %12
%13 = integer_literal $Builtin.Word, 1 // user: %15
%14 = builtin_function_ref "sadd_with_overflow_Word" : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %15
%15 = apply %14(%5, %13, %6) : $@thin (Builtin.Word, Builtin.Word, Builtin.Int1) -> (Builtin.Word, Builtin.Int1) // user: %16
%16 = tuple_extract %15 : $(Builtin.Word, Builtin.Int1), 0 // users: %18, %21
%17 = builtin_function_ref "cmp_sgt_Word" : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %18
%18 = apply %17(%16, %5) : $@thin (Builtin.Word, Builtin.Word) -> Builtin.Int1 // user: %19
%19 = apply %10(%18, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %20
cond_fail %19 : $Builtin.Int1 // id: %20
%21 = struct $Int (%16 : $Builtin.Word) // user: %22
%22 = struct $Range<Int> (%1 : $Int, %21 : $Int) // user: %24
retain_value %4 : $Optional<Builtin.NativeObject> // id: %23
%24 = apply %3<T>(%22, %2) : $@cc(method) @thin <τ_0_0> (Range<Int>, @owned _ArrayBuffer<τ_0_0>) -> ()
// function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool
%25 = function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %27
retain_value %4 : $Optional<Builtin.NativeObject> // id: %26
%27 = apply %25<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %28
%28 = struct_extract %27 : $Bool, #Bool.value // user: %30
%29 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %30
%30 = apply %29(%28, %7) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %31
cond_br %30, bb1, bb2 // id: %31
bb1: // Preds: bb0
// function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A>
%32 = function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A> : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %34
retain_value %4 : $Optional<Builtin.NativeObject> // id: %33
%34 = apply %32<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %36
// function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A
%35 = function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Int) -> A : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> () // user: %36
%36 = apply %35<T>(%0, %1, %34) : $@cc(method) @thin <τ_0_0> (@out τ_0_0, Int, @owned _ContiguousArrayBuffer<τ_0_0>) -> ()
br bb3 // id: %37
bb2: // Preds: bb0
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%38 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %54
%39 = alloc_stack $AnyObject // users: %52, %54, %56
// function_ref Swift._ArrayBuffer._nonNative.getter : Swift.Optional<Swift._SwiftNSArrayRequiredOverridesType>
%40 = function_ref Swift._ArrayBuffer._nonNative.getter : Swift._SwiftNSArrayRequiredOverridesType? : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned Optional<_SwiftNSArrayRequiredOverridesType> // user: %42
retain_value %4 : $Optional<Builtin.NativeObject> // id: %41
%42 = apply %40<T>(%2) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned Optional<_SwiftNSArrayRequiredOverridesType> // users: %43, %47
switch_enum %42 : $Optional<_SwiftNSArrayRequiredOverridesType>, case #Optional.Some!enumelt.1: bb4, case #Optional.None!enumelt: bb5 // id: %43
bb3: // Preds: bb1 bb4
release_value %4 : $Optional<Builtin.NativeObject> // id: %44
%45 = tuple () // user: %46
return %45 : $() // id: %46
bb4: // Preds: bb2
%47 = unchecked_enum_data %42 : $Optional<_SwiftNSArrayRequiredOverridesType>, #Optional.Some!enumelt.1 // users: %48, %49, %55
%48 = project_existential_ref %47 : $_SwiftNSArrayRequiredOverridesType to $@sil_self _SwiftNSArrayRequiredOverridesType // user: %50
%49 = protocol_method [volatile] %47 : $_SwiftNSArrayRequiredOverridesType, #_SwiftNSArrayRequiredOverridesType.objectAtIndex!1.foreign : <`Self` : _SwiftNSArrayRequiredOverridesType> Self -> (Int) -> AnyObject, $@cc(objc_method) @thin (Int, @sil_self _SwiftNSArrayRequiredOverridesType) -> @autoreleased AnyObject // user: %50
%50 = apply %49(%1, %48) : $@cc(objc_method) @thin (Int, @sil_self _SwiftNSArrayRequiredOverridesType) -> @autoreleased AnyObject // users: %51, %52
strong_retain_autoreleased %50 : $AnyObject // id: %51
store %50 to %39#1 : $*AnyObject // id: %52
%53 = metatype $@thick T.Type // user: %54
%54 = apply [transparent] %38<AnyObject, T>(%0, %39#1, %53) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
strong_release %47 : $_SwiftNSArrayRequiredOverridesType // id: %55
dealloc_stack %39#0 : $*@local_storage AnyObject // id: %56
br bb3 // id: %57
bb5: // Preds: bb2
cond_fail %7 : $Builtin.Int1 // id: %58
unreachable // id: %59
}
// Swift._ArrayBuffer._typeCheck <A>(Swift._ArrayBuffer<A>)(Swift.Range<Swift.Int>) -> ()
sil public_external Swift._ArrayBuffer._typeCheck <A>(Swift._ArrayBuffer<A>)(Swift.Range<Swift.Int>) -> () : $@cc(method) @thin <T> (Range<Int>, @owned _ArrayBuffer<T>) -> () {
bb0(%0 : $Range<Int>, %1 : $_ArrayBuffer<T>):
%2 = alloc_stack $IndexingGenerator<_SliceBuffer<T>> // users: %27, %52, %56, %79, %97
%3 = alloc_stack $T // users: %26, %69, %73, %94
%4 = alloc_stack $RangeGenerator<Int> // users: %25, %108, %115
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%5 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %7
%6 = metatype $@thick T.Type // user: %7
%7 = apply %5<T>(%6) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %8
%8 = struct_extract %7 : $Bool, #Bool.value // user: %9
cond_br %8, bb1, bb2 // id: %9
bb1: // Preds: bb0
%10 = struct_extract %1 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // users: %12, %31, %47, %101
// function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer
%11 = function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // user: %13
retain_value %10 : $Optional<Builtin.NativeObject> // id: %12
%13 = apply %11<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // users: %14, %20
%14 = ref_element_addr %13 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.needsElementTypeCheck // user: %15
%15 = struct_element_addr %14 : $*Bool, #Bool.value // user: %16
%16 = load %15 : $*Builtin.Int1 // user: %19
%17 = integer_literal $Builtin.Int1, 0 // users: %19, %86, %144
%18 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // users: %19, %41
%19 = apply %18(%16, %17) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %21
strong_release %13 : $_IndirectArrayBuffer // id: %20
cond_br %19, bb3, bb2 // id: %21
bb2: // Preds: bb0 bb1 bb5 bb7 bb16
%22 = struct_extract %1 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %23
release_value %22 : $Optional<Builtin.NativeObject> // id: %23
%24 = tuple () // user: %28
dealloc_stack %4#0 : $*@local_storage RangeGenerator<Int> // id: %25
dealloc_stack %3#0 : $*@local_storage T // id: %26
dealloc_stack %2#0 : $*@local_storage IndexingGenerator<_SliceBuffer<T>> // id: %27
return %24 : $() // id: %28
bb3: // Preds: bb1
%29 = alloc_stack $Bool // users: %33, %36, %43
// function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool
%30 = function_ref Swift._ArrayBuffer._isNative.getter : Swift.Bool : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %32
retain_value %10 : $Optional<Builtin.NativeObject> // id: %31
%32 = apply %30<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> Bool // user: %33
store %32 to %29#1 : $*Bool // id: %33
%34 = alloc_stack $Bool // users: %37, %39, %42
// function_ref protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType
%35 = function_ref protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType : $@cc(witness_method) @thin (@inout Bool) -> Bool // users: %36, %39
%36 = apply %35(%29#1) : $@cc(witness_method) @thin (@inout Bool) -> Bool // user: %37
store %36 to %34#1 : $*Bool // id: %37
%38 = integer_literal $Builtin.Int1, -1 // users: %41, %85, %92, %112, %140, %143, %149
%39 = apply %35(%34#1) : $@cc(witness_method) @thin (@inout Bool) -> Bool // user: %40
%40 = struct_extract %39 : $Bool, #Bool.value // user: %41
%41 = apply %18(%40, %38) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %44
dealloc_stack %34#0 : $*@local_storage Bool // id: %42
dealloc_stack %29#0 : $*@local_storage Bool // id: %43
cond_br %41, bb4, bb5 // id: %44
bb4: // Preds: bb3
// function_ref Swift._SliceBuffer.generate <A>(Swift._SliceBuffer<A>)() -> Swift.IndexingGenerator<Swift._SliceBuffer<A>>
%45 = function_ref Swift._SliceBuffer.generate <A>(Swift._SliceBuffer<A>)() -> Swift.IndexingGenerator<Swift._SliceBuffer<A>> : $@cc(method) @thin <τ_0_0> (@owned _SliceBuffer<τ_0_0>) -> @owned IndexingGenerator<_SliceBuffer<τ_0_0>> // user: %51
// function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A>
%46 = function_ref Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A> : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %48
retain_value %10 : $Optional<Builtin.NativeObject> // id: %47
%48 = apply %46<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %50
// function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Range<Swift.Int>) -> Swift._SliceBuffer<A>
%49 = function_ref Swift._ContiguousArrayBuffer.subscript.getter (Swift.Range<Swift.Int>) -> Swift._SliceBuffer<A> : $@cc(method) @thin <τ_0_0> (Range<Int>, @owned _ContiguousArrayBuffer<τ_0_0>) -> @owned _SliceBuffer<τ_0_0> // user: %50
%50 = apply %49<T>(%0, %48) : $@cc(method) @thin <τ_0_0> (Range<Int>, @owned _ContiguousArrayBuffer<τ_0_0>) -> @owned _SliceBuffer<τ_0_0> // user: %51
%51 = apply %45<T>(%50) : $@cc(method) @thin <τ_0_0> (@owned _SliceBuffer<τ_0_0>) -> @owned IndexingGenerator<_SliceBuffer<τ_0_0>> // user: %52
store %51 to %2#1 : $*IndexingGenerator<_SliceBuffer<T>> // id: %52
%53 = alloc_stack $Optional<T> // users: %56, %57, %68, %78, %97, %98
// function_ref Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> Swift.Optional<A._Element>
%54 = function_ref Swift.IndexingGenerator.next <A : Swift._CollectionType>(inout Swift.IndexingGenerator<A>)() -> A._Element? : $@cc(method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0._Element>, @inout IndexingGenerator<τ_0_0>) -> () // users: %56, %97
// function_ref Swift._doesOptionalHaveValue <A>(inout Swift.Optional<A>) -> Builtin.Int1
%55 = function_ref Swift._doesOptionalHaveValue <A>(inout A?) -> Builtin.Int1 : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // users: %57, %98
%56 = apply %54<_SliceBuffer<T>, Int, Int, Int, Int, T>(%53#1, %2#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0._Element>, @inout IndexingGenerator<τ_0_0>) -> ()
%57 = apply [transparent] %55<T>(%53#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %58
cond_br %57, bb6, bb7 // id: %58
bb5: // Preds: bb3
%59 = alloc_stack $Range<Int> // users: %60, %62, %64
store %0 to %59#1 : $*Range<Int> // id: %60
// function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.isEmpty.getter : Swift.Bool
%61 = function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.isEmpty.getter : Swift.Bool : $@cc(method) @thin (@in Range<Int>) -> Bool // user: %62
%62 = apply %61(%59#1) : $@cc(method) @thin (@in Range<Int>) -> Bool // user: %63
%63 = struct_extract %62 : $Bool, #Bool.value // user: %65
dealloc_stack %59#0 : $*@local_storage Range<Int> // id: %64
cond_br %63, bb2, bb11 // id: %65
bb6: // Preds: bb4 bb10
%66 = alloc_stack $T // users: %68, %69, %95, %96
// function_ref Swift._getOptionalValue <A>(Swift.Optional<A>) -> A
%67 = function_ref Swift._getOptionalValue <A>(A?) -> A : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> () // user: %68
%68 = apply [transparent] %67<T>(%66#1, %53#1) : $@thin <τ_0_0> (@out τ_0_0, @in Optional<τ_0_0>) -> ()
copy_addr %66#1 to [initialization] %3#1 : $*T // id: %69
%70 = alloc_stack $AnyObject // users: %75, %77, %90
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%71 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %75
%72 = alloc_stack $T // users: %73, %75, %89
copy_addr %3#1 to [initialization] %72#1 : $*T // id: %73
%74 = metatype $@thick AnyObject.Protocol // user: %75
%75 = apply [transparent] %71<T, AnyObject>(%70#1, %72#1, %74) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%76 = alloc_stack $T // users: %77, %84, %88
checked_cast_addr_br take_always AnyObject in %70#1 : $*AnyObject to T in %76#1 : $*T, bb8, bb9 // id: %77
bb7: // Preds: bb4 bb10
dealloc_stack %53#0 : $*@local_storage Optional<T> // id: %78
%79 = struct_element_addr %2#1 : $*IndexingGenerator<_SliceBuffer<T>>, #IndexingGenerator._elements // user: %80
%80 = struct_element_addr %79 : $*_SliceBuffer<T>, #_SliceBuffer.owner // user: %81
%81 = load %80 : $*Optional<AnyObject> // user: %82
release_value %81 : $Optional<AnyObject> // id: %82
br bb2 // id: %83
bb8: // Preds: bb6
destroy_addr %76#1 : $*T // id: %84
br bb10(%38 : $Builtin.Int1) // id: %85
bb9: // Preds: bb6
br bb10(%17 : $Builtin.Int1) // id: %86
bb10(%87 : $Builtin.Int1): // Preds: bb8 bb9
dealloc_stack %76#0 : $*@local_storage T // id: %88
dealloc_stack %72#0 : $*@local_storage T // id: %89
dealloc_stack %70#0 : $*@local_storage AnyObject // id: %90
%91 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %92
%92 = apply %91(%87, %38) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %93
cond_fail %92 : $Builtin.Int1 // id: %93
destroy_addr %3#1 : $*T // id: %94
destroy_addr %66#1 : $*T // id: %95
dealloc_stack %66#0 : $*@local_storage T // id: %96
%97 = apply %54<_SliceBuffer<T>, Int, Int, Int, Int, T>(%53#1, %2#1) : $@cc(method) @thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out Optional<τ_0_0._Element>, @inout IndexingGenerator<τ_0_0>) -> ()
%98 = apply [transparent] %55<T>(%53#1) : $@thin <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %99
cond_br %98, bb6, bb7 // id: %99
bb11: // Preds: bb5
// function_ref Swift._ArrayBuffer._nonNative.getter : Swift.Optional<Swift._SwiftNSArrayRequiredOverridesType>
%100 = function_ref Swift._ArrayBuffer._nonNative.getter : Swift._SwiftNSArrayRequiredOverridesType? : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned Optional<_SwiftNSArrayRequiredOverridesType> // user: %102
retain_value %10 : $Optional<Builtin.NativeObject> // id: %101
%102 = apply %100<T>(%1) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned Optional<_SwiftNSArrayRequiredOverridesType> // users: %103, %104
switch_enum %102 : $Optional<_SwiftNSArrayRequiredOverridesType>, case #Optional.Some!enumelt.1: bb12, case #Optional.None!enumelt: bb13 // id: %103
bb12: // Preds: bb11
%104 = unchecked_enum_data %102 : $Optional<_SwiftNSArrayRequiredOverridesType>, #Optional.Some!enumelt.1 // users: %128, %132, %133, %134, %151
%105 = alloc_stack $Range<Int> // users: %106, %108, %109
store %0 to %105#1 : $*Range<Int> // id: %106
// function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A>
%107 = function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.Range.generate <A : Swift.ForwardIndexType>(Swift.Range<A>)() -> Swift.RangeGenerator<A> : $@cc(method) @thin (@out RangeGenerator<Int>, @in Range<Int>) -> () // user: %108
%108 = apply %107(%4#1, %105#1) : $@cc(method) @thin (@out RangeGenerator<Int>, @in Range<Int>) -> ()
dealloc_stack %105#0 : $*@local_storage Range<Int> // id: %109
%110 = alloc_stack $Optional<Int> // users: %115, %116, %124, %127
br bb14 // id: %111
bb13: // Preds: bb11
cond_fail %38 : $Builtin.Int1 // id: %112
unreachable // id: %113
bb14: // Preds: bb12 bb21
// function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> Swift.Optional<A>
%114 = function_ref specialization <Swift.Int with Swift.Int : Swift.ForwardIndexType, Swift.Int with Swift.Int : Swift._SignedIntegerType, Swift.Int with Swift.Int : Swift._BuiltinIntegerLiteralConvertible, Swift.Int> of Swift.RangeGenerator.next <A : Swift.ForwardIndexType>(inout Swift.RangeGenerator<A>)() -> A? : $@cc(method) @thin (@out Optional<Int>, @inout RangeGenerator<Int>) -> () // user: %115
%115 = apply %114(%110#1, %4#1) : $@cc(method) @thin (@out Optional<Int>, @inout RangeGenerator<Int>) -> ()
%116 = load %110#1 : $*Optional<Int> // users: %118, %124, %126, %130
%117 = alloc_stack $Optional<Int> // users: %118, %121, %123
store %116 to %117#1 : $*Optional<Int> // id: %118
%119 = struct $_OptionalNilComparisonType () // user: %121
// function_ref specialization <Swift.Int> of Swift.!= infix <A>(Swift.Optional<A>, Swift._OptionalNilComparisonType) -> Swift.Bool
%120 = function_ref specialization <Swift.Int> of Swift.!= infix <A>(A?, Swift._OptionalNilComparisonType) -> Swift.Bool : $@thin (@in Optional<Int>, _OptionalNilComparisonType) -> Bool // user: %121
%121 = apply %120(%117#1, %119) : $@thin (@in Optional<Int>, _OptionalNilComparisonType) -> Bool // user: %122
%122 = struct_extract %121 : $Bool, #Bool.value // user: %125
dealloc_stack %117#0 : $*@local_storage Optional<Int> // id: %123
store %116 to %110#1 : $*Optional<Int> // id: %124
cond_br %122, bb15, bb16 // id: %125
bb15: // Preds: bb14
switch_enum %116 : $Optional<Int>, case #Optional.Some!enumelt.1: bb17, case #Optional.None!enumelt: bb18 // id: %126
bb16: // Preds: bb14
dealloc_stack %110#0 : $*@local_storage Optional<Int> // id: %127
strong_release %104 : $_SwiftNSArrayRequiredOverridesType // id: %128
br bb2 // id: %129
bb17: // Preds: bb15
%130 = unchecked_enum_data %116 : $Optional<Int>, #Optional.Some!enumelt.1 // user: %135
%131 = alloc_stack $AnyObject // users: %137, %139, %147
%132 = project_existential_ref %104 : $_SwiftNSArrayRequiredOverridesType to $@sil_self _SwiftNSArrayRequiredOverridesType // user: %135
%133 = protocol_method [volatile] %104 : $_SwiftNSArrayRequiredOverridesType, #_SwiftNSArrayRequiredOverridesType.objectAtIndex!1.foreign : <`Self` : _SwiftNSArrayRequiredOverridesType> Self -> (Int) -> AnyObject, $@cc(objc_method) @thin (Int, @sil_self _SwiftNSArrayRequiredOverridesType) -> @autoreleased AnyObject // user: %135
strong_retain %104 : $_SwiftNSArrayRequiredOverridesType // id: %134
%135 = apply %133(%130, %132) : $@cc(objc_method) @thin (Int, @sil_self _SwiftNSArrayRequiredOverridesType) -> @autoreleased AnyObject // users: %136, %137
strong_retain_autoreleased %135 : $AnyObject // id: %136
store %135 to %131#1 : $*AnyObject // id: %137
%138 = alloc_stack $T // users: %139, %142, %146
checked_cast_addr_br take_always AnyObject in %131#1 : $*AnyObject to T in %138#1 : $*T, bb19, bb20 // id: %139
bb18: // Preds: bb15
cond_fail %38 : $Builtin.Int1 // id: %140
unreachable // id: %141
bb19: // Preds: bb17
destroy_addr %138#1 : $*T // id: %142
br bb21(%38 : $Builtin.Int1) // id: %143
bb20: // Preds: bb17
br bb21(%17 : $Builtin.Int1) // id: %144
bb21(%145 : $Builtin.Int1): // Preds: bb19 bb20
dealloc_stack %138#0 : $*@local_storage T // id: %146
dealloc_stack %131#0 : $*@local_storage AnyObject // id: %147
%148 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %149
%149 = apply %148(%145, %38) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %150
cond_fail %149 : $Builtin.Int1 // id: %150
strong_release %104 : $_SwiftNSArrayRequiredOverridesType // id: %151
br bb14 // id: %152
}
// Swift._ArrayBuffer._isNative.getter : Swift.Bool
sil public_external Swift._ArrayBuffer._isNative.getter : Swift.Bool : $@cc(method) @thin <T> (@owned _ArrayBuffer<T>) -> Bool {
bb0(%0 : $_ArrayBuffer<T>):
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
%4 = struct_extract %3 : $Bool, #Bool.value // user: %5
cond_br %4, bb1, bb2 // id: %5
bb1: // Preds: bb0
%6 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %8
// function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer
%7 = function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // user: %9
retain_value %6 : $Optional<Builtin.NativeObject> // id: %8
%9 = apply %7<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // users: %10, %16
%10 = ref_element_addr %9 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %11
%11 = struct_element_addr %10 : $*Bool, #Bool.value // user: %12
%12 = load %11 : $*Builtin.Int1 // user: %15
%13 = integer_literal $Builtin.Int1, -1 // user: %15
%14 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %15
%15 = apply %14(%12, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
strong_release %9 : $_IndirectArrayBuffer // id: %16
br bb3(%15 : $Builtin.Int1) // id: %17
bb2: // Preds: bb0
%18 = integer_literal $Builtin.Int1, -1 // user: %19
br bb3(%18 : $Builtin.Int1) // id: %19
bb3(%20 : $Builtin.Int1): // Preds: bb1 bb2
%21 = struct $Bool (%20 : $Builtin.Int1) // user: %24
%22 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %23
release_value %22 : $Optional<Builtin.NativeObject> // id: %23
return %21 : $Bool // id: %24
}
// Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A>
sil public_external Swift._ArrayBuffer._native.getter : Swift._ContiguousArrayBuffer<A> : $@cc(method) @thin <T> (@owned _ArrayBuffer<T>) -> @owned _ContiguousArrayBuffer<T> {
bb0(%0 : $_ArrayBuffer<T>):
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // users: %3, %40
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
%4 = struct_extract %3 : $Bool, #Bool.value // user: %5
cond_br %4, bb1, bb2 // id: %5
bb1: // Preds: bb0
%6 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %8
// function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer
%7 = function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // user: %9
retain_value %6 : $Optional<Builtin.NativeObject> // id: %8
%9 = apply %7<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // users: %10, %39, %40, %47
%10 = ref_element_addr %9 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %11
%11 = struct_element_addr %10 : $*Bool, #Bool.value // user: %12
%12 = load %11 : $*Builtin.Int1 // user: %15
%13 = integer_literal $Builtin.Int1, -1 // users: %15, %17
%14 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %15
%15 = apply %14(%12, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_br %17, bb4, bb5 // id: %18
bb2: // Preds: bb0
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift.Optional<Swift._ContiguousArrayStorage<A>>) -> Swift._ContiguousArrayBuffer<A>
%19 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)(Swift._ContiguousArrayStorage<A>?) -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %30
%20 = metatype $@thin _ContiguousArrayBuffer<T>.Type // user: %30
// function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B
%21 = function_ref Swift.unsafeBitCast <A, B>(A, B.Type) -> B : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> () // user: %28
%22 = alloc_stack $Optional<Builtin.NativeObject> // users: %24, %28, %32
%23 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // users: %24, %27
store %23 to %22#1 : $*Optional<Builtin.NativeObject> // id: %24
%25 = metatype $@thick Optional<_ContiguousArrayStorage<T>>.Type // user: %28
%26 = alloc_stack $Optional<_ContiguousArrayStorage<T>> // users: %28, %29, %31
retain_value %23 : $Optional<Builtin.NativeObject> // id: %27
%28 = apply [transparent] %21<Builtin.NativeObject?, _ContiguousArrayStorage<T>?>(%26#1, %22#1, %25) : $@thin <τ_0_0, τ_0_1> (@out τ_0_1, @in τ_0_0, @thick τ_0_1.Type) -> ()
%29 = load %26#1 : $*Optional<_ContiguousArrayStorage<T>> // user: %30
%30 = apply %19<T>(%29, %20) : $@thin <τ_0_0> (@owned Optional<_ContiguousArrayStorage<τ_0_0>>, @thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %33
dealloc_stack %26#0 : $*@local_storage Optional<_ContiguousArrayStorage<T>> // id: %31
dealloc_stack %22#0 : $*@local_storage Optional<Builtin.NativeObject> // id: %32
br bb3(%30 : $_ContiguousArrayBuffer<T>) // id: %33
bb3(%34 : $_ContiguousArrayBuffer<T>): // Preds: bb2 bb6
%35 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %36
release_value %35 : $Optional<Builtin.NativeObject> // id: %36
return %34 : $_ContiguousArrayBuffer<T> // id: %37
bb4: // Preds: bb1
// function_ref Swift._IndirectArrayBuffer.getNativeBufferOf (Swift._IndirectArrayBuffer)<A>(A.Type) -> Swift._ContiguousArrayBuffer<A>
%38 = function_ref Swift._IndirectArrayBuffer.getNativeBufferOf (Swift._IndirectArrayBuffer)<A>(A.Type) -> Swift._ContiguousArrayBuffer<A> : $@cc(method) @thin <τ_0_0> (@thick τ_0_0.Type, @owned _IndirectArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %40
strong_retain %9 : $_IndirectArrayBuffer // id: %39
%40 = apply %38<T>(%2, %9) : $@cc(method) @thin <τ_0_0> (@thick τ_0_0.Type, @owned _IndirectArrayBuffer) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %41
br bb6(%40 : $_ContiguousArrayBuffer<T>) // id: %41
bb5: // Preds: bb1
// function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A>
%42 = function_ref Swift._ContiguousArrayBuffer.init <A>(Swift._ContiguousArrayBuffer<A>.Type)() -> Swift._ContiguousArrayBuffer<A> : $@thin <τ_0_0> (@thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %44
%43 = metatype $@thin _ContiguousArrayBuffer<T>.Type // user: %44
%44 = apply %42<T>(%43) : $@thin <τ_0_0> (@thin _ContiguousArrayBuffer<τ_0_0>.Type) -> @owned _ContiguousArrayBuffer<τ_0_0> // user: %45
br bb6(%44 : $_ContiguousArrayBuffer<T>) // id: %45
bb6(%46 : $_ContiguousArrayBuffer<T>): // Preds: bb4 bb5
strong_release %9 : $_IndirectArrayBuffer // id: %47
br bb3(%46 : $_ContiguousArrayBuffer<T>) // id: %48
}
// Swift._ArrayBuffer._nonNative.getter : Swift.Optional<Swift._SwiftNSArrayRequiredOverridesType>
sil public_external Swift._ArrayBuffer._nonNative.getter : Swift._SwiftNSArrayRequiredOverridesType? : $@cc(method) @thin <T> (@owned _ArrayBuffer<T>) -> @owned Optional<_SwiftNSArrayRequiredOverridesType> {
bb0(%0 : $_ArrayBuffer<T>):
// function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool
%1 = function_ref Swift._isClassOrObjCExistential <A>(A.Type) -> Swift.Bool : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %3
%2 = metatype $@thick T.Type // user: %3
%3 = apply %1<T>(%2) : $@thin <τ_0_0> (@thick τ_0_0.Type) -> Bool // user: %4
%4 = struct_extract %3 : $Bool, #Bool.value // user: %5
cond_br %4, bb1, bb2 // id: %5
bb1: // Preds: bb0
%6 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %8
// function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer
%7 = function_ref Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // user: %9
retain_value %6 : $Optional<Builtin.NativeObject> // id: %8
%9 = apply %7<T>(%0) : $@cc(method) @thin <τ_0_0> (@owned _ArrayBuffer<τ_0_0>) -> @owned _IndirectArrayBuffer // users: %10, %28, %29, %33
%10 = ref_element_addr %9 : $_IndirectArrayBuffer, #_IndirectArrayBuffer.isCocoa // user: %11
%11 = struct_element_addr %10 : $*Bool, #Bool.value // user: %12
%12 = load %11 : $*Builtin.Int1 // user: %15
%13 = integer_literal $Builtin.Int1, -1 // users: %15, %17
%14 = builtin_function_ref "xor_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %15
%15 = apply %14(%12, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%16 = builtin_function_ref "int_expect_Int1" : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %17
%17 = apply %16(%15, %13) : $@thin (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 // user: %18
cond_br %17, bb4, bb5 // id: %18
bb2: // Preds: bb0
%19 = enum $Optional<_SwiftNSArrayRequiredOverridesType>, #Optional.None!enumelt // user: %20
br bb3(%19 : $Optional<_SwiftNSArrayRequiredOverridesType>) // id: %20
bb3(%21 : $Optional<_SwiftNSArrayRequiredOverridesType>): // Preds: bb2 bb6
%22 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // user: %23
release_value %22 : $Optional<Builtin.NativeObject> // id: %23
return %21 : $Optional<_SwiftNSArrayRequiredOverridesType> // id: %24
bb4: // Preds: bb1
%25 = enum $Optional<_SwiftNSArrayRequiredOverridesType>, #Optional.None!enumelt // user: %26
br bb6(%25 : $Optional<_SwiftNSArrayRequiredOverridesType>) // id: %26
bb5: // Preds: bb1
// function_ref Swift._IndirectArrayBuffer.getCocoa (Swift._IndirectArrayBuffer)() -> Swift._SwiftNSArrayRequiredOverridesType
%27 = function_ref Swift._IndirectArrayBuffer.getCocoa (Swift._IndirectArrayBuffer)() -> Swift._SwiftNSArrayRequiredOverridesType : $@cc(method) @thin (@owned _IndirectArrayBuffer) -> @owned _SwiftNSArrayRequiredOverridesType // user: %29
strong_retain %9 : $_IndirectArrayBuffer // id: %28
%29 = apply %27(%9) : $@cc(method) @thin (@owned _IndirectArrayBuffer) -> @owned _SwiftNSArrayRequiredOverridesType // user: %30
%30 = enum $Optional<_SwiftNSArrayRequiredOverridesType>, #Optional.Some!enumelt.1, %29 : $_SwiftNSArrayRequiredOverridesType // user: %31
br bb6(%30 : $Optional<_SwiftNSArrayRequiredOverridesType>) // id: %31
bb6(%32 : $Optional<_SwiftNSArrayRequiredOverridesType>): // Preds: bb4 bb5
strong_release %9 : $_IndirectArrayBuffer // id: %33
br bb3(%32 : $Optional<_SwiftNSArrayRequiredOverridesType>) // id: %34
}
// Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer
sil public_external Swift._ArrayBuffer.indirect.getter : Swift._IndirectArrayBuffer : $@cc(method) @thin <T> (@owned _ArrayBuffer<T>) -> @owned _IndirectArrayBuffer {
bb0(%0 : $_ArrayBuffer<T>):
%1 = struct_extract %0 : $_ArrayBuffer<T>, #_ArrayBuffer.storage // users: %2, %3
switch_enum %1 : $Optional<Builtin.NativeObject>, case #Optional.Some!enumelt.1: bb1, case #Optional.None!enumelt: bb2 // id: %2
bb1: // Preds: bb0
%3 = unchecked_enum_data %1 : $Optional<Builtin.NativeObject>, #Optional.Some!enumelt.1 // user: %4
%4 = unchecked_ref_cast %3 : $Builtin.NativeObject to $_IndirectArrayBuffer // user: %5
return %4 : $_IndirectArrayBuffer // id: %5
bb2: // Preds: bb0
%6 = integer_literal $Builtin.Int1, -1 // user: %7
cond_fail %6 : $Builtin.Int1 // id: %7
unreachable // id: %8
}
// protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType
sil public_external protocol witness for Swift.BooleanType.boolValue.getter : Swift.Bool in conformance Swift.Bool : Swift.BooleanType : $@cc(witness_method) @thin (@inout Bool) -> Bool {
bb0(%0 : $*Bool):
%1 = load %0 : $*Bool // user: %2
return %1 : $Bool // id: %2
}
// Swift._SliceBuffer.generate <A>(Swift._SliceBuffer<A>)() -> Swift.IndexingGenerator<Swift._SliceBuffer<A>>
sil public_external Swift._SliceBuffer.generate <A>(Swift._SliceBuffer<A>)() -> Swift.IndexingGenerator<Swift._SliceBuffer<A>> : $@cc(method) @thin <T> (@owned _SliceBuffer<T>) -> @owned IndexingGenerator<_SliceBuffer<T>> {
bb0(%0 : $_SliceBuffer<T>):
// function_ref Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A>
%1 = function_ref Swift.IndexingGenerator.init <A : Swift._CollectionType>(Swift.IndexingGenerator<A>.Type)(A) -> Swift.IndexingGenerator<A> : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out IndexingGenerator<τ_0_0>, @in τ_0_0, @thin IndexingGenerator<τ_0_0>.Type) -> () // user: %6
%2 = metatype $@thin IndexingGenerator<_SliceBuffer<T>>.Type // user: %6
%3 = alloc_stack $_SliceBuffer<T> // users: %4, %6, %9
store %0 to %3#1 : $*_SliceBuffer<T> // id: %4
%5 = alloc_stack $IndexingGenerator<_SliceBuffer<T>> // users: %6, %7, %8
%6 = apply %1<_SliceBuffer<T>, Int, Int, Int, Int, T>(%5#1, %3#1, %2) : $@thin <τ_0_0 where τ_0_0 : _CollectionType, τ_0_0.Index : ForwardIndexType, τ_0_0.Index.Distance : _SignedIntegerType, τ_0_0.Index.Distance.IntegerLiteralType : _BuiltinIntegerLiteralConvertible> (@out IndexingGenerator<τ_0_0>, @in τ_0_0, @thin IndexingGenerator<τ_0_0>.Type) -> ()
%7 = load %5#1 : $*IndexingGenerator<_SliceBuffer<T>> // user: %10
dealloc_stack %5#0 : $*@local_storage IndexingGenerator<_SliceBuffer<T>> // id: %8
dealloc_stack %3#0 : $*@local_storage _SliceBuffer<T> // id: %9
return %7 : $IndexingGenerator<_SliceBuffer<T>> // id: %10
}
// Swift._ContiguousArrayBuffer.subscript.getter (Swift.Range<Swift.Int>) -> Swift._SliceBuffer<A>
sil public_external Swift._ContiguousArrayBuffer.subscript.getter (Swift.Range<Swift.Int>) -> Swift._SliceBuffer<A> : $@cc(method) @thin <T> (Range<Int>, @owned _ContiguousArrayBuffer<T>) -> @owned _SliceBuffer<T> {
bb0(%0 : $Range<Int>, %1 : $_ContiguousArrayBuffer<T>):
// function_ref Swift._SliceBuffer.init <A>(Swift._SliceBuffer<A>.Type)(owner : Swift.Optional<Swift.AnyObject>, start : Swift.UnsafeMutablePointer<A>, count : Swift.Int, hasNativeBuffer : Swift.Bool) -> Swift._SliceBuffer<A>
Raw
indexof.swift
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment