#if os(Linux)
import Glibc
#else
import Darwin.C
#endif

let INPUT = stdin

var buffer: UnsafeMutablePointer<CChar>?
var bufferCapacity: Int32 = 0

func getsToBuffer(size: Int32) -> UnsafeMutablePointer<CChar> {
    if bufferCapacity < size {
        buffer?.deallocate()
        buffer = UnsafeMutablePointer.allocate(capacity: Int(size))
        bufferCapacity = size
    }
    return fgets(buffer!, size, INPUT)
}
func getIntFromBuffer(_ ptr: inout UnsafeMutablePointer<CChar>) -> Int {
    var minus = false
    var x: Int?
    while true {
        switch ptr.pointee {
        case 0x2D:
            assert(!minus && x == nil)
            minus = true
        case let d where (0x30...0x39).contains(d):
            x = (x ?? 0)*10 + Int(d)-0x30
        default:
            if x != nil { return minus ? -x! : x! }
        }
        ptr += 1
    }
}
func getInt() -> Int {
    var xPtr = getsToBuffer(size: 24)
    return getIntFromBuffer(&xPtr)
}
func getIntPair() -> (Int, Int) {
    var xPtr = getsToBuffer(size: 2*24)
    let x1 = getIntFromBuffer(&xPtr)
    let x2 = getIntFromBuffer(&xPtr)
    return (x1, x2)
}
func getInts(count: Int) -> [Int] {
    var xPtr = getsToBuffer(size: Int32(count) * 24)
    var a = [Int]()
    a.reserveCapacity(count)
    for _ in 0..<count { a.append(getIntFromBuffer(&xPtr)) }
    return a
}

func scanString(maxLength: Int = 255) -> String {
    let ptr = UnsafeMutablePointer<CChar>.allocate(capacity: maxLength+1)
    let read = withVaList([ptr]) {
        vfscanf(INPUT, "%\(maxLength)s", $0)
    }
    assert(read == 1)
    return String(cString: ptr)
}

//=============================================================================

struct FenwickTree<Element> {
    let count: Int
    private let defaultValue: Element
    private var tree: [Element]
    private let combine: (Element, _ adding: Element) -> Element
    private let inverse: (Element, _ removing: Element) -> Element

    init(count: Int,
         defaultValue: Element,
         addBy combine: @escaping (Element, _ adding: Element) -> Element,
         removeBy inverse: @escaping (Element, _ removing: Element) -> Element
    ) {
        tree = [Element](repeating: defaultValue, count: count)
        self.count = count
        self.defaultValue = defaultValue
        self.combine = combine
        self.inverse = inverse
    }

    mutating func update(at i: Int, adding value: Element) {
        assert(0 <= i && i < count)
        var i = i
        if i == 0 {
            tree[0] = combine(tree[0], value)
            return
        }
        repeat {
            tree[i] = combine(tree[i], value)
            i += i & -i  // increment LSB
        } while i < count
    }
    func query(range r: Range<Int>) -> Element {
        assert(0 <= r.lowerBound && r.upperBound <= count)
        var i = r.upperBound - 1
        var j = r.lowerBound - 1
        var sigma = defaultValue
        if i < 0 { return sigma }
        if j < 0 {
            sigma = combine(sigma, tree[0])
            j = 0
        }
        while i > j {
            sigma = combine(sigma, tree[i])
            i &= i-1  // decrement LSB
        }
        while j > i {
            sigma = inverse(sigma, tree[j])
            j &= j-1  // decrement LSB
        }
        return sigma
    }
}

//=============================================================================

let (N, Q) = getIntPair()
let c = getInts(count: N).map { $0 - 1 }

var queries = [(l: Int, r: Int)]()
queries.reserveCapacity(Q)
for _ in 1...Q {
    let (l, r) = getIntPair()
    queries.append((l: l-1, r: r-1+1))
}
var responses = [Int?](repeating: nil, count: Q)

var queue = queries.enumerated().sorted { $0.1.r > $1.1.r }
var lastSeen = [Int?](repeating: nil, count: N)
var counter = FenwickTree(count: N, defaultValue: 0, addBy: (+), removeBy: (-))

for (i, x) in c.enumerated() {
    if let j = lastSeen[x] {
        counter.update(at: j, adding: -1)
    }
    lastSeen[x] = i
    counter.update(at: i, adding: +1)

    while queue.last?.1.r == i+1 {
        let (queryId, q) = queue.removeLast()
        responses[queryId] = counter.query(range: q.l..<q.r)
    }
}

print(responses.map { String($0!) } .joined(separator: "\n"))

; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/Swift/Source_2332/llvm_OZ.ll'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/Swift/Source_2332/llvm_OZ.ll"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%TSpySo8_IO_FILEVGSg = type <{ [8 x i8] }>
%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, %struct._IO_codecvt*, %struct._IO_wide_data*, %struct._IO_FILE*, i8*, i64, i32, [20 x i8] }
%struct._IO_marker = type opaque
%struct._IO_codecvt = type opaque
%struct._IO_wide_data = type opaque
%TSpys4Int8VGSg = type <{ [8 x i8] }>
%Ts5Int32V = type <{ i32 }>
%TSi = type <{ i64 }>
%TSa = type <{ %Ts22_ContiguousArrayBufferV }>
%Ts22_ContiguousArrayBufferV = type <{ %Ts28__ContiguousArrayStorageBaseC* }>
%Ts28__ContiguousArrayStorageBaseC = type <{ %swift.refcounted, %Ts10_ArrayBodyV }>
%swift.refcounted = type { %swift.type*, i64 }
%swift.type = type { i64 }
%Ts10_ArrayBodyV = type <{ %TSo22_SwiftArrayBodyStorageV }>
%TSo22_SwiftArrayBodyStorageV = type <{ %TSi, %TSu }>
%TSu = type <{ i64 }>
%T7llvm_OZ11FenwickTreeVySiG = type <{ %TSi, %TSi, %TSa, %swift.function, %swift.function }>
%swift.function = type { i8*, %swift.refcounted* }
%struct._SwiftEmptyArrayStorage = type { %struct.HeapObject, %struct._SwiftArrayBodyStorage }
%struct.HeapObject = type { %struct.HeapMetadata*, %struct.InlineRefCountsPlaceholder }
%struct.HeapMetadata = type opaque
%struct.InlineRefCountsPlaceholder = type { i64 }
%struct._SwiftArrayBodyStorage = type { i64, i64 }
%swift.type_descriptor = type opaque
%swift.protocol_conformance_descriptor = type { i32, i32, i32, i32 }
%swift.protocol = type { i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i32, i32, i32, i32, i32, i32 }
%swift.vwtable = type { i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i64, i64, i32, i32 }
%swift.type_metadata_record = type { i32 }
%Ts15ContiguousArrayV = type <{ %Ts22_ContiguousArrayBufferV }>
%swift.error = type opaque
%swift.opaque = type opaque
%swift.bridge = type opaque
%TSS = type <{ %Ts11_StringGutsV }>
%Ts11_StringGutsV = type <{ %Ts13_StringObjectV }>
%Ts13_StringObjectV = type <{ %Ts6UInt64V, %swift.bridge* }>
%Ts6UInt64V = type <{ i64 }>
%TSp = type <{ i8* }>
%Ts4Int8V = type <{ i8 }>
%Ts15__VaListBuilderC = type <{ %swift.refcounted, %TSi, %TSi, %Ts15__VaListBuilderC6HeaderV, %Ts15ContiguousArrayV, %TSa }>
%Ts15__VaListBuilderC6HeaderV = type <{ %Ts6UInt32V, %Ts6UInt32V, %TSpySiGSg, %TSpySiGSg }>
%Ts6UInt32V = type <{ i32 }>
%TSpySiGSg = type <{ [8 x i8] }>
%swift.metadata_response = type { %swift.type*, i64 }
%Ts7CVarArgP = type { [24 x i8], %swift.type*, i8** }
%Ts23_ContiguousArrayStorageCys7CVarArg_pG = type <{ %swift.refcounted, %Ts10_ArrayBodyV }>
%struct.__va_list_tag = type { i32, i32, i8*, i8* }
%T7llvm_OZ11FenwickTreeV = type <{ %TSi }>
%TSrySi6offset_Si1l_Si1rt7elementtG = type <{ %TSpySi6offset_Si1l_Si1rt7elementtGSg, %TSi }>
%TSpySi6offset_Si1l_Si1rt7elementtGSg = type <{ [8 x i8] }>
%TSnySiG = type <{ %TSi, %TSi }>

@"$s7llvm_OZ5INPUTSpySo8_IO_FILEVGSgvp" = hidden local_unnamed_addr global %TSpySo8_IO_FILEVGSg zeroinitializer, align 8
@stdin = external local_unnamed_addr global %struct._IO_FILE*, align 8
@"$s7llvm_OZ6bufferSpys4Int8VGSgvp" = hidden global %TSpys4Int8VGSg zeroinitializer, align 8
@"$s7llvm_OZ14bufferCapacitys5Int32Vvp" = hidden global %Ts5Int32V zeroinitializer, align 4
@"$s7llvm_OZ1NSivp" = hidden local_unnamed_addr global %TSi zeroinitializer, align 8
@"$s7llvm_OZ1QSivp" = hidden local_unnamed_addr global %TSi zeroinitializer, align 8
@"$s7llvm_OZ1cSaySiGvp" = hidden local_unnamed_addr global %TSa zeroinitializer, align 8
@"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp" = hidden global %TSa zeroinitializer, align 8
@"$s7llvm_OZ9responsesSaySiSgGvp" = hidden global %TSa zeroinitializer, align 8
@"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp" = hidden global %TSa zeroinitializer, align 8
@"$s7llvm_OZ8lastSeenSaySiSgGvp" = hidden global %TSa zeroinitializer, align 8
@"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp" = hidden global %T7llvm_OZ11FenwickTreeVySiG zeroinitializer, align 8
@_swiftEmptyArrayStorage = external global %struct._SwiftEmptyArrayStorage, align 8
@"$ss23_ContiguousArrayStorageCMn" = external global %swift.type_descriptor, align 4
@"got.$ss23_ContiguousArrayStorageCMn" = private unnamed_addr constant %swift.type_descriptor* @"$ss23_ContiguousArrayStorageCMn"
@"symbolic _____yypG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [4 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [4 x i8], i8 }>, <{ i8, i32, [4 x i8], i8 }>* @"symbolic _____yypG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [4 x i8] c"yypG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCyypGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [4 x i8], i8 }>* @"symbolic _____yypG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCyypGMD" to i64)) to i32), i32 -9 }, align 8
@"$sSiN" = external global %swift.type, align 8
@"$sSis23CustomStringConvertiblesWP" = external global i8*, align 8
@"symbolic SaySSG" = linkonce_odr hidden constant <{ [6 x i8], i8 }> <{ [6 x i8] c"SaySSG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$sSaySSGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ [6 x i8], i8 }>* @"symbolic SaySSG" to i64), i64 ptrtoint ({ i32, i32 }* @"$sSaySSGMD" to i64)) to i32), i32 -6 }, align 8
@"$sSaySSGSayxGSKsWL" = linkonce_odr hidden local_unnamed_addr global i8** null, align 8
@"$sSayxGSKsMc" = external global %swift.protocol_conformance_descriptor, align 4
@"$sSSN" = external global %swift.type, align 8
@"$ss7CVarArgMp" = external global %swift.protocol, align 4
@"got.$ss7CVarArgMp" = private unnamed_addr constant %swift.protocol* @"$ss7CVarArgMp"
@"symbolic _____y______pG s23_ContiguousArrayStorageC s7CVarArgP" = linkonce_odr hidden constant <{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }>, <{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }>* @"symbolic _____y______pG s23_ContiguousArrayStorageC s7CVarArgP", i32 0, i32 1) to i64)) to i32), [1 x i8] c"y", i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.protocol** @"got.$ss7CVarArgMp" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }>, <{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }>* @"symbolic _____y______pG s23_ContiguousArrayStorageC s7CVarArgP", i32 0, i32 4) to i64)) to i32), [3 x i8] c"_pG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCys7CVarArg_pGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [1 x i8], i8, i32, [3 x i8], i8 }>* @"symbolic _____y______pG s23_ContiguousArrayStorageC s7CVarArgP" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCys7CVarArg_pGMD" to i64)) to i32), i32 -14 }, align 8
@"$ss4Int8VMn" = external global %swift.type_descriptor, align 4
@"got.$ss4Int8VMn" = private unnamed_addr constant %swift.type_descriptor* @"$ss4Int8VMn"
@"symbolic Spy_____G s4Int8V" = linkonce_odr hidden constant <{ [3 x i8], i8, i32, [1 x i8], i8 }> <{ [3 x i8] c"Spy", i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss4Int8VMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ [3 x i8], i8, i32, [1 x i8], i8 }>, <{ [3 x i8], i8, i32, [1 x i8], i8 }>* @"symbolic Spy_____G s4Int8V", i32 0, i32 2) to i64)) to i32), [1 x i8] c"G", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$sSpys4Int8VGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ [3 x i8], i8, i32, [1 x i8], i8 }>* @"symbolic Spy_____G s4Int8V" to i64), i64 ptrtoint ({ i32, i32 }* @"$sSpys4Int8VGMD" to i64)) to i32), i32 -9 }, align 8
@"$sSpys4Int8VGSpyxGs7CVarArgsWL" = linkonce_odr hidden local_unnamed_addr global i8** null, align 8
@"$sSpyxGs7CVarArgsMc" = external global %swift.protocol_conformance_descriptor, align 4
@"\01l_entry_point" = private constant { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (i32 (i32, i8**)* @main to i64), i64 ptrtoint ({ i32, i32 }* @"\01l_entry_point" to i64)) to i32), i32 0 }, section "swift5_entry", align 4
@"$s7llvm_OZ11FenwickTreeVWV" = internal constant %swift.vwtable { i8* bitcast (%swift.opaque* ([24 x i8]*, [24 x i8]*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwCP" to i8*), i8* bitcast (void (%swift.opaque*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwxx" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwcp" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwca" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwtk" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwta" to i8*), i8* bitcast (i32 (%swift.opaque*, i32, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwet" to i8*), i8* bitcast (void (%swift.opaque*, i32, i32, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVwst" to i8*), i64 0, i64 0, i32 4194304, i32 0 }, align 8
@.str.7.llvm_OZ = private constant [8 x i8] c"llvm_OZ\00"
@"$s7llvm_OZMXM" = linkonce_odr hidden constant <{ i32, i32, i32 }> <{ i32 0, i32 0, i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.7.llvm_OZ to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32 }>, <{ i32, i32, i32 }>* @"$s7llvm_OZMXM", i32 0, i32 2) to i64)) to i32) }>, section ".rodata", no_sanitize_address, align 4
@.str.11.FenwickTree = private constant [12 x i8] c"FenwickTree\00"
@"$s7llvm_OZ11FenwickTreeVMI" = internal global [16 x i8*] zeroinitializer, align 8
@"$s7llvm_OZ11FenwickTreeVMn" = hidden constant <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }> <{ i32 209, i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32 }>* @"$s7llvm_OZMXM" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 1) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([12 x i8]* @.str.11.FenwickTree to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (%swift.metadata_response (i64, %swift.type*)* @"$s7llvm_OZ11FenwickTreeVMa" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 3) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 4) to i64)) to i32), i32 5, i32 3, i32 trunc (i64 sub (i64 ptrtoint ([16 x i8*]* @"$s7llvm_OZ11FenwickTreeVMI" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 7) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32 }>* @"$s7llvm_OZ11FenwickTreeVMP" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn", i32 0, i32 8) to i64)) to i32), i16 1, i16 0, i16 1, i16 0, i8 -128, i8 0, i8 0, i8 0 }>, section ".rodata", no_sanitize_address, align 4
@"$sBi64_WV" = external global i8*, align 8
@"$sBoWV" = external global i8*, align 8
@"$syycWV" = external global i8*, align 8
@"$s7llvm_OZ11FenwickTreeVMP" = internal constant <{ i32, i32, i32, i32 }> <{ i32 trunc (i64 sub (i64 ptrtoint (%swift.type* (%swift.type_descriptor*, i8**, i8*)* @"$s7llvm_OZ11FenwickTreeVMi" to i64), i64 ptrtoint (<{ i32, i32, i32, i32 }>* @"$s7llvm_OZ11FenwickTreeVMP" to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (%swift.metadata_response (%swift.type*, i8*, i8**)* @"$s7llvm_OZ11FenwickTreeVMr" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32 }>, <{ i32, i32, i32, i32 }>* @"$s7llvm_OZ11FenwickTreeVMP", i32 0, i32 1) to i64)) to i32), i32 1073741824, i32 trunc (i64 sub (i64 ptrtoint (%swift.vwtable* @"$s7llvm_OZ11FenwickTreeVWV" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32 }>, <{ i32, i32, i32, i32 }>* @"$s7llvm_OZ11FenwickTreeVMP", i32 0, i32 3) to i64)) to i32) }>, align 8
@"symbolic _____ 7llvm_OZ11FenwickTreeV" = linkonce_odr hidden constant <{ i8, i32, i8 }> <{ i8 1, i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, i8 }>, <{ i8, i32, i8 }>* @"symbolic _____ 7llvm_OZ11FenwickTreeV", i32 0, i32 1) to i64)) to i32), i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"symbolic Si" = linkonce_odr hidden constant <{ [2 x i8], i8 }> <{ [2 x i8] c"Si", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@0 = private constant [6 x i8] c"count\00", section "swift5_reflstr", no_sanitize_address
@"symbolic x" = linkonce_odr hidden constant <{ [1 x i8], i8 }> <{ [1 x i8] c"x", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@1 = private constant [13 x i8] c"defaultValue\00", section "swift5_reflstr", no_sanitize_address
@"symbolic SayxG" = linkonce_odr hidden constant <{ [5 x i8], i8 }> <{ [5 x i8] c"SayxG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@2 = private constant [5 x i8] c"tree\00", section "swift5_reflstr", no_sanitize_address
@"symbolic xx_xtc" = linkonce_odr hidden constant <{ [6 x i8], i8 }> <{ [6 x i8] c"xx_xtc", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@3 = private constant [8 x i8] c"combine\00", section "swift5_reflstr", no_sanitize_address
@4 = private constant [8 x i8] c"inverse\00", section "swift5_reflstr", no_sanitize_address
@"$s7llvm_OZ11FenwickTreeVMF" = internal constant { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, i8 }>* @"symbolic _____ 7llvm_OZ11FenwickTreeV" to i64), i64 ptrtoint ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF" to i64)) to i32), i32 0, i16 0, i16 12, i32 5, i32 0, i32 trunc (i64 sub (i64 ptrtoint (<{ [2 x i8], i8 }>* @"symbolic Si" to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 6) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([6 x i8]* @0 to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 7) to i64)) to i32), i32 0, i32 trunc (i64 sub (i64 ptrtoint (<{ [1 x i8], i8 }>* @"symbolic x" to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 9) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([13 x i8]* @1 to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 10) to i64)) to i32), i32 2, i32 trunc (i64 sub (i64 ptrtoint (<{ [5 x i8], i8 }>* @"symbolic SayxG" to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 12) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @2 to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 13) to i64)) to i32), i32 0, i32 trunc (i64 sub (i64 ptrtoint (<{ [6 x i8], i8 }>* @"symbolic xx_xtc" to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 15) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @3 to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 16) to i64)) to i32), i32 0, i32 trunc (i64 sub (i64 ptrtoint (<{ [6 x i8], i8 }>* @"symbolic xx_xtc" to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 18) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @4 to i64), i64 ptrtoint (i32* getelementptr inbounds ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }, { i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF", i32 0, i32 19) to i64)) to i32) }, section "swift5_fieldmd", no_sanitize_address, align 4
@"symbolic ______p s7CVarArgP" = linkonce_odr hidden constant <{ i8, i32, [2 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.protocol** @"got.$ss7CVarArgMp" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [2 x i8], i8 }>, <{ i8, i32, [2 x i8], i8 }>* @"symbolic ______p s7CVarArgP", i32 0, i32 1) to i64)) to i32), [2 x i8] c"_p", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss7CVarArg_pMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [2 x i8], i8 }>* @"symbolic ______p s7CVarArgP" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss7CVarArg_pMD" to i64)) to i32), i32 -7 }, align 8
@"symbolic _____ySiG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [4 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [4 x i8], i8 }>, <{ i8, i32, [4 x i8], i8 }>* @"symbolic _____ySiG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [4 x i8] c"ySiG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySiGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [4 x i8], i8 }>* @"symbolic _____ySiG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySiGMD" to i64)) to i32), i32 -9 }, align 8
@"symbolic _____ySi6offset_Si1l_Si1rt7elementtG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [31 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [31 x i8], i8 }>, <{ i8, i32, [31 x i8], i8 }>* @"symbolic _____ySi6offset_Si1l_Si1rt7elementtG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [31 x i8] c"ySi6offset_Si1l_Si1rt7elementtG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySi6offset_Si1l_Si1rt7elementtGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [31 x i8], i8 }>* @"symbolic _____ySi6offset_Si1l_Si1rt7elementtG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySi6offset_Si1l_Si1rt7elementtGMD" to i64)) to i32), i32 -36 }, align 8
@"symbolic Si6offset_Si1l_Si1rt7elementt" = linkonce_odr hidden constant <{ [29 x i8], i8 }> <{ [29 x i8] c"Si6offset_Si1l_Si1rt7elementt", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$sSi6offset_Si1l_Si1rt7elementtMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ [29 x i8], i8 }>* @"symbolic Si6offset_Si1l_Si1rt7elementt" to i64), i64 ptrtoint ({ i32, i32 }* @"$sSi6offset_Si1l_Si1rt7elementtMD" to i64)) to i32), i32 -29 }, align 8
@"symbolic _____ySSG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [4 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [4 x i8], i8 }>, <{ i8, i32, [4 x i8], i8 }>* @"symbolic _____ySSG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [4 x i8] c"ySSG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySSGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [4 x i8], i8 }>* @"symbolic _____ySSG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySSGMD" to i64)) to i32), i32 -9 }, align 8
@"symbolic _____ySiSgG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [6 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [6 x i8], i8 }>, <{ i8, i32, [6 x i8], i8 }>* @"symbolic _____ySiSgG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [6 x i8] c"ySiSgG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySiSgGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [6 x i8], i8 }>* @"symbolic _____ySiSgG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySiSgGMD" to i64)) to i32), i32 -11 }, align 8
@"symbolic SiSg" = linkonce_odr hidden constant <{ [4 x i8], i8 }> <{ [4 x i8] c"SiSg", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$sSiSgMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ [4 x i8], i8 }>* @"symbolic SiSg" to i64), i64 ptrtoint ({ i32, i32 }* @"$sSiSgMD" to i64)) to i32), i32 -4 }, align 8
@"symbolic _____ySnySiGG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [8 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [8 x i8], i8 }>, <{ i8, i32, [8 x i8], i8 }>* @"symbolic _____ySnySiGG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [8 x i8] c"ySnySiGG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySnySiGGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [8 x i8], i8 }>* @"symbolic _____ySnySiGG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySnySiGGMD" to i64)) to i32), i32 -13 }, align 8
@"symbolic _____ySi1l_Si1rtG s23_ContiguousArrayStorageC" = linkonce_odr hidden constant <{ i8, i32, [12 x i8], i8 }> <{ i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss23_ContiguousArrayStorageCMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [12 x i8], i8 }>, <{ i8, i32, [12 x i8], i8 }>* @"symbolic _____ySi1l_Si1rtG s23_ContiguousArrayStorageC", i32 0, i32 1) to i64)) to i32), [12 x i8] c"ySi1l_Si1rtG", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCySi1l_Si1rtGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [12 x i8], i8 }>* @"symbolic _____ySi1l_Si1rtG s23_ContiguousArrayStorageC" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCySi1l_Si1rtGMD" to i64)) to i32), i32 -17 }, align 8
@"$s7llvm_OZ11FenwickTreeVHn" = private constant %swift.type_metadata_record { i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn" to i64), i64 ptrtoint (%swift.type_metadata_record* @"$s7llvm_OZ11FenwickTreeVHn" to i64)) to i32) }, section "swift5_type_metadata", no_sanitize_address, align 4
@__swift_reflection_version = linkonce_odr hidden constant i16 3
@_swift1_autolink_entries = private constant [116 x i8] c"-lswiftGlibc\00-lswiftCore\00-lm\00-lpthread\00-lutil\00-ldl\00-lswift_Concurrency\00-lswift_StringProcessing\00-lswift_RegexParser\00", section ".swift1_autolink_entries", no_sanitize_address, align 8
@llvm.compiler.used = appending global [6 x i8*] [i8* bitcast ({ i32, i32 }* @"\01l_entry_point" to i8*), i8* bitcast (%swift.type_metadata_record* @"$s7llvm_OZ11FenwickTreeVHn" to i8*), i8* bitcast ({ i32, i32, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }* @"$s7llvm_OZ11FenwickTreeVMF" to i8*), i8* bitcast (i16* @__swift_reflection_version to i8*), i8* getelementptr inbounds ([116 x i8], [116 x i8]* @_swift1_autolink_entries, i32 0, i32 0), i8* bitcast (i32 (i32, i8**)* @main to i8*)], section "llvm.metadata"

; Function Attrs: minsize optsize
define protected i32 @main(i32 %0, i8** nocapture readnone %1) #0 {
entry:
  %2 = alloca %Ts15ContiguousArrayV, align 8
  %access-scratch = alloca [24 x i8], align 8
  %3 = alloca %Ts15ContiguousArrayV, align 8
  %swifterror = alloca swifterror %swift.error*, align 8
  store %swift.error* null, %swift.error** %swifterror, align 8
  %access-scratch19 = alloca [24 x i8], align 8
  %access-scratch25 = alloca [24 x i8], align 8
  %access-scratch26 = alloca [24 x i8], align 8
  %access-scratch27 = alloca [24 x i8], align 8
  %access-scratch31 = alloca [24 x i8], align 8
  %4 = alloca %Ts15ContiguousArrayV, align 8
  %5 = alloca %TSi, align 8
  %6 = alloca %TSa, align 8
  %7 = alloca %TSi, align 8
  %8 = alloca %TSi, align 8
  %9 = alloca %TSi, align 8
  %10 = alloca %TSi, align 8
  %11 = alloca %TSi, align 8
  %12 = alloca %TSi, align 8
  %13 = alloca %TSi, align 8
  %access-scratch72 = alloca [24 x i8], align 8
  %14 = load i64, i64* bitcast (%struct._IO_FILE** @stdin to i64*), align 8
  store i64 %14, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_OZ5INPUTSpySo8_IO_FILEVGSgvp" to i64*), align 8
  store i64 0, i64* bitcast (%TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp" to i64*), align 8
  store i32 0, i32* getelementptr inbounds (%Ts5Int32V, %Ts5Int32V* @"$s7llvm_OZ14bufferCapacitys5Int32Vvp", i64 0, i32 0), align 4
  %15 = tail call swiftcc { i64, i64 } @"$s7llvm_OZ10getIntPairSi_SityF"()
  %16 = extractvalue { i64, i64 } %15, 0
  %17 = extractvalue { i64, i64 } %15, 1
  store i64 %16, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1NSivp", i64 0, i32 0), align 8
  store i64 %17, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1QSivp", i64 0, i32 0), align 8
  %18 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$s7llvm_OZ7getInts5countSaySiGSi_tF"(i64 %16)
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 1, i32 0, i32 0, i32 0
  %19 = load i64, i64* %._storage.count._value, align 8, !range !6
  %20 = icmp eq i64 %19, 0
  br i1 %20, label %21, label %23

21:                                               ; preds = %entry
  %22 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %22) #9
  br label %26

23:                                               ; preds = %entry
  %24 = bitcast %Ts15ContiguousArrayV* %2 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %24)
  %._buffer._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %2, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSi_Tg5"(i1 false, i64 %19, i1 false, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %2)
  %25 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %25 to %TSi*
  br label %31

26:                                               ; preds = %21, %57
  %27 = phi %Ts28__ContiguousArrayStorageBaseC* [ %53, %57 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %21 ]
  store %Ts28__ContiguousArrayStorageBaseC* %27, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ1cSaySiGvp", i64 0, i32 0, i32 0), align 8
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  %28 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1QSivp", i64 0, i32 0), align 8
  %29 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %29)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp" to i8*), [24 x i8]* nonnull %access-scratch, i64 1, i8* null) #9
  call swiftcc void @"$sSa15reserveCapacityyySiFSi1l_Si1rt_Tg5"(i64 %28, %TSa* nocapture nonnull swiftself dereferenceable(8) @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp")
  %30 = icmp slt i64 %28, 1
  br i1 %30, label %348, label %.preheader, !prof !7

31:                                               ; preds = %52, %23
  %32 = phi i64 [ 0, %23 ], [ %54, %52 ]
  %._value = getelementptr inbounds %TSi, %TSi* %tailaddr, i64 %32, i32 0
  %33 = load i64, i64* %._value, align 8
  %34 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %33, i64 -1)
  %35 = extractvalue { i64, i1 } %34, 0
  %36 = extractvalue { i64, i1 } %34, 1
  br i1 %36, label %347, label %37, !prof !7

37:                                               ; preds = %31
  %38 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %39 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %38, i64 0, i32 0
  %40 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %39) #27
  br i1 %40, label %44, label %41

41:                                               ; preds = %37
  %._storage4.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %38, i64 0, i32 1, i32 0, i32 0, i32 0
  %42 = load i64, i64* %._storage4.count._value, align 8, !range !6
  %43 = add nuw nsw i64 %42, 1
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSi_Tg5"(i1 false, i64 %43, i1 true, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %2)
  %.pre = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  br label %44

44:                                               ; preds = %37, %41
  %45 = phi %Ts28__ContiguousArrayStorageBaseC* [ %38, %37 ], [ %.pre, %41 ]
  %._storage5.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %45, i64 0, i32 1, i32 0, i32 0, i32 0
  %46 = load i64, i64* %._storage5.count._value, align 8, !range !6
  %._storage5._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %45, i64 0, i32 1, i32 0, i32 1, i32 0
  %47 = load i64, i64* %._storage5._capacityAndFlags._value, align 8
  %48 = lshr i64 %47, 1
  %49 = add nuw nsw i64 %46, 1
  %.not = icmp ugt i64 %48, %46
  br i1 %.not, label %52, label %50, !prof !8

50:                                               ; preds = %44
  %51 = icmp ugt i64 %47, 1
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSi_Tg5"(i1 %51, i64 %49, i1 true, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %2)
  %.pre127 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  br label %52

52:                                               ; preds = %44, %50
  %53 = phi %Ts28__ContiguousArrayStorageBaseC* [ %45, %44 ], [ %.pre127, %50 ]
  %54 = add nuw nsw i64 %32, 1
  %._storage6.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %53, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %49, i64* %._storage6.count._value, align 8
  %55 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %53, i64 1
  %tailaddr7 = bitcast %Ts28__ContiguousArrayStorageBaseC* %55 to %TSi*
  %._value8 = getelementptr inbounds %TSi, %TSi* %tailaddr7, i64 %46, i32 0
  store i64 %35, i64* %._value8, align 8
  %56 = icmp eq i64 %54, %19
  br i1 %56, label %57, label %31

57:                                               ; preds = %52
  %58 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %58) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %24)
  br label %26

59:                                               ; preds = %92
  %60 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %63, i64 1)
  %61 = extractvalue { i64, i1 } %60, 0
  %62 = extractvalue { i64, i1 } %60, 1
  br i1 %62, label %351, label %.preheader, !prof !7

.preheader:                                       ; preds = %26, %59
  %63 = phi i64 [ %61, %59 ], [ 1, %26 ]
  %64 = call swiftcc { i64, i64 } @"$s7llvm_OZ10getIntPairSi_SityF"()
  %65 = extractvalue { i64, i64 } %64, 0
  %66 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %65, i64 -1)
  %67 = extractvalue { i64, i1 } %66, 0
  %68 = extractvalue { i64, i1 } %66, 1
  br i1 %68, label %349, label %69, !prof !7

69:                                               ; preds = %.preheader
  %70 = extractvalue { i64, i64 } %64, 1
  %71 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %70, i64 -1)
  %72 = extractvalue { i64, i1 } %71, 1
  br i1 %72, label %350, label %73, !prof !7

73:                                               ; preds = %69
  %74 = extractvalue { i64, i1 } %71, 0
  %75 = add nsw i64 %74, 1
  %76 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  %77 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %76, i64 0, i32 0
  %78 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %77) #27
  store %Ts28__ContiguousArrayStorageBaseC* %76, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  br i1 %78, label %83, label %79

79:                                               ; preds = %73
  %._storage10.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %76, i64 0, i32 1, i32 0, i32 0, i32 0
  %80 = load i64, i64* %._storage10.count._value, align 8, !range !6
  %81 = add nuw nsw i64 %80, 1
  %82 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi1l_Si1rt_Tg5"(i1 false, i64 %81, i1 true, %Ts28__ContiguousArrayStorageBaseC* %76)
  store %Ts28__ContiguousArrayStorageBaseC* %82, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  br label %83

83:                                               ; preds = %73, %79
  %84 = phi %Ts28__ContiguousArrayStorageBaseC* [ %76, %73 ], [ %82, %79 ]
  %._storage11.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %84, i64 0, i32 1, i32 0, i32 0, i32 0
  %85 = load i64, i64* %._storage11.count._value, align 8, !range !6
  %._storage11._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %84, i64 0, i32 1, i32 0, i32 1, i32 0
  %86 = load i64, i64* %._storage11._capacityAndFlags._value, align 8
  %87 = lshr i64 %86, 1
  %88 = add nuw nsw i64 %85, 1
  %.not105 = icmp ugt i64 %87, %85
  br i1 %.not105, label %92, label %89, !prof !8

89:                                               ; preds = %83
  %90 = icmp ugt i64 %86, 1
  %91 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi1l_Si1rt_Tg5"(i1 %90, i64 %88, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull %84)
  store %Ts28__ContiguousArrayStorageBaseC* %91, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  br label %92

92:                                               ; preds = %83, %89
  %93 = phi %Ts28__ContiguousArrayStorageBaseC* [ %84, %83 ], [ %91, %89 ]
  %94 = icmp eq i64 %63, %28
  %._storage12.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %93, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %88, i64* %._storage12.count._value, align 8
  %95 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %93, i64 1
  %tailaddr13 = bitcast %Ts28__ContiguousArrayStorageBaseC* %95 to <{ %TSi, %TSi }>*
  %.l._value = getelementptr inbounds <{ %TSi, %TSi }>, <{ %TSi, %TSi }>* %tailaddr13, i64 %85, i32 0, i32 0
  store i64 %67, i64* %.l._value, align 8
  %.r._value = getelementptr inbounds <{ %TSi, %TSi }>, <{ %TSi, %TSi }>* %tailaddr13, i64 %85, i32 1, i32 0
  store i64 %75, i64* %.r._value, align 8
  br i1 %94, label %96, label %59

96:                                               ; preds = %92
  %97 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1QSivp", i64 0, i32 0), align 8
  %98 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCSiSg_Tg5"(i64 0, i8 1, i64 %97)
  store %Ts28__ContiguousArrayStorageBaseC* %98, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ9responsesSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  %99 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ7queriesSaySi1l_Si1rtGvp", i64 0, i32 0, i32 0), align 8
  %100 = bitcast %Ts15ContiguousArrayV* %3 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %100)
  %101 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %99, i64 0, i32 0
  %102 = bitcast %Ts28__ContiguousArrayStorageBaseC* %99 to %swift.refcounted*
  %103 = call %swift.refcounted* @swift_retain_n(%swift.refcounted* %102, i32 2)
  %104 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss30_copySequenceToContiguousArrayys0dE0Vy7ElementQzGxSTRzlFs010EnumeratedB0VySaySi1l_Si1rtGG_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %99)
  call void @swift_release(%swift.refcounted* %101) #9
  %._buffer14._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %3, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %104, %Ts28__ContiguousArrayStorageBaseC** %._buffer14._storage, align 8
  call swiftcc void @"$sSMsSkRzrlE4sort2byySb7ElementSTQz_ADtKXE_tKFs15ContiguousArrayVySi6offset_Si1l_Si1rt7elementtG_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_m3AC_M13ADtAEttXEfU0_Tf1cn_n"(%Ts15ContiguousArrayV* nocapture nonnull dereferenceable(8) %3, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture nonnull swifterror dereferenceable(8) %swifterror)
  %105 = load %swift.error*, %swift.error** %swifterror, align 8
  %.not106 = icmp eq %swift.error* %105, null
  br i1 %.not106, label %106, label %115

106:                                              ; preds = %96
  call void @swift_release(%swift.refcounted* %101) #9
  %107 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer14._storage, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %100)
  store %Ts28__ContiguousArrayStorageBaseC* %107, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  %108 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1NSivp", i64 0, i32 0), align 8
  %109 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCSiSg_Tg5"(i64 0, i8 1, i64 %108)
  store %Ts28__ContiguousArrayStorageBaseC* %109, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  %110 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_OZ1NSivp", i64 0, i32 0), align 8
  %111 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCSi_Tg5"(i64 0, i64 %110)
  store i64 %110, i64* getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 0, i32 0), align 8
  store i64 0, i64* getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 1, i32 0), align 8
  store %Ts28__ContiguousArrayStorageBaseC* %111, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 2, i32 0, i32 0), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_OZS2i_Sitcfu1_" to i8*), i8** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 1), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_OZS2i_Sitcfu2_" to i8*), i8** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 1), align 8
  %112 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ1cSaySiGvp", i64 0, i32 0, i32 0), align 8
  %._storage17.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %112, i64 0, i32 1, i32 0, i32 0, i32 0
  %113 = load i64, i64* %._storage17.count._value, align 8, !range !6
  %114 = icmp eq i64 %113, 0
  br i1 %114, label %283, label %118

115:                                              ; preds = %96
  %116 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer14._storage, align 8
  %117 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %116, i64 0, i32 0
  call void @swift_release(%swift.refcounted* %117) #9
  unreachable

118:                                              ; preds = %106
  %119 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %112, i64 1
  %tailaddr18 = bitcast %Ts28__ContiguousArrayStorageBaseC* %119 to %TSi*
  %120 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %112, i64 0, i32 0
  %121 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch19, i64 0, i64 0
  %122 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %120) #27
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %121)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp" to i8*), [24 x i8]* nonnull %access-scratch19, i64 1, i8* null) #9
  %123 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch72, i64 0, i64 0
  %124 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch25, i64 0, i64 0
  %125 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch26, i64 0, i64 0
  %126 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch27, i64 0, i64 0
  %127 = bitcast %TSi* %7 to i8*
  %._value52 = getelementptr inbounds %TSi, %TSi* %7, i64 0, i32 0
  %128 = bitcast %TSi* %12 to i8*
  %129 = bitcast %TSi* %13 to i8*
  %._value69 = getelementptr inbounds %TSi, %TSi* %13, i64 0, i32 0
  %._value70 = getelementptr inbounds %TSi, %TSi* %12, i64 0, i32 0
  %130 = bitcast %TSi* %10 to i8*
  %131 = bitcast %TSi* %11 to i8*
  %._value64 = getelementptr inbounds %TSi, %TSi* %11, i64 0, i32 0
  %._value65 = getelementptr inbounds %TSi, %TSi* %10, i64 0, i32 0
  %132 = bitcast %TSi* %8 to i8*
  %133 = bitcast %TSi* %9 to i8*
  %._value58 = getelementptr inbounds %TSi, %TSi* %9, i64 0, i32 0
  %._value59 = getelementptr inbounds %TSi, %TSi* %8, i64 0, i32 0
  br label %134

134:                                              ; preds = %._crit_edge, %118
  %135 = phi i64 [ 0, %118 ], [ %139, %._crit_edge ]
  %136 = load i64, i64* %._storage17.count._value, align 8, !range !6
  %.not107 = icmp ult i64 %135, %136
  br i1 %.not107, label %137, label %352, !prof !8

137:                                              ; preds = %134
  %._value20 = getelementptr inbounds %TSi, %TSi* %tailaddr18, i64 %135, i32 0
  %138 = load i64, i64* %._value20, align 8
  %139 = add nuw nsw i64 %135, 1
  %140 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  %141 = icmp slt i64 %138, 0
  br i1 %141, label %353, label %142, !prof !7

142:                                              ; preds = %137
  %._storage21.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %140, i64 0, i32 1, i32 0, i32 0, i32 0
  %143 = load i64, i64* %._storage21.count._value, align 8, !range !6
  %.not108 = icmp ult i64 %138, %143
  br i1 %.not108, label %144, label %354, !prof !8

144:                                              ; preds = %142
  %145 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %140, i64 1
  %146 = bitcast %Ts28__ContiguousArrayStorageBaseC* %145 to i8*
  %147 = shl nsw i64 %138, 4
  %148 = getelementptr inbounds i8, i8* %146, i64 %147
  %149 = getelementptr inbounds i8, i8* %148, i64 8
  %150 = bitcast i8* %149 to i1*
  %151 = load i1, i1* %150, align 1
  br i1 %151, label %155, label %152

152:                                              ; preds = %144
  %153 = bitcast i8* %148 to i64*
  %154 = load i64, i64* %153, align 1
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %123)
  call void @swift_beginAccess(i8* nonnull bitcast (%T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp" to i8*), [24 x i8]* nonnull %access-scratch72, i64 33, i8* null) #9
  call swiftcc void @"$s7llvm_OZ11FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %154, i64 -1, %T7llvm_OZ11FenwickTreeVySiG* nocapture nonnull swiftself dereferenceable(56) @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp")
  call void @swift_endAccess([24 x i8]* nonnull %access-scratch72) #9
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %123)
  %.pre128 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  br label %155

155:                                              ; preds = %144, %152
  %156 = phi %Ts28__ContiguousArrayStorageBaseC* [ %140, %144 ], [ %.pre128, %152 ]
  %157 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %156, i64 0, i32 0
  %158 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %157) #27
  store %Ts28__ContiguousArrayStorageBaseC* %156, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  br i1 %158, label %161, label %159

159:                                              ; preds = %155
  %160 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSiSg_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %156)
  store %Ts28__ContiguousArrayStorageBaseC* %160, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ8lastSeenSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  br label %161

161:                                              ; preds = %155, %159
  %162 = phi %Ts28__ContiguousArrayStorageBaseC* [ %156, %155 ], [ %160, %159 ]
  %._storage23.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %162, i64 0, i32 1, i32 0, i32 0, i32 0
  %163 = load i64, i64* %._storage23.count._value, align 8, !range !6
  %.not109 = icmp ult i64 %138, %163
  br i1 %.not109, label %164, label %355, !prof !8

164:                                              ; preds = %161
  %165 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %162, i64 1
  %166 = bitcast %Ts28__ContiguousArrayStorageBaseC* %165 to i8*
  %167 = getelementptr inbounds i8, i8* %166, i64 %147
  %168 = bitcast i8* %167 to i64*
  store i64 %135, i64* %168, align 1
  %169 = getelementptr inbounds i8, i8* %167, i64 8
  %170 = bitcast i8* %169 to i1*
  store i1 false, i1* %170, align 1
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %124)
  call void @swift_beginAccess(i8* nonnull bitcast (%T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp" to i8*), [24 x i8]* nonnull %access-scratch25, i64 33, i8* null) #9
  call swiftcc void @"$s7llvm_OZ11FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %135, i64 1, %T7llvm_OZ11FenwickTreeVySiG* nocapture nonnull swiftself dereferenceable(56) @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp")
  call void @swift_endAccess([24 x i8]* nonnull %access-scratch25) #9
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %124)
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %125)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp" to i8*), [24 x i8]* nonnull %access-scratch26, i64 1, i8* null) #9
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %126)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_OZ9responsesSaySiSgGvp" to i8*), [24 x i8]* nonnull %access-scratch27, i64 1, i8* null) #9
  %171 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  %._storage28.count._value121 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %171, i64 0, i32 1, i32 0, i32 0, i32 0
  %172 = load i64, i64* %._storage28.count._value121, align 8, !range !6
  %173 = icmp eq i64 %172, 0
  br i1 %173, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %164, %228
  %174 = phi i64 [ %237, %228 ], [ %172, %164 ]
  %175 = phi %Ts28__ContiguousArrayStorageBaseC* [ %236, %228 ], [ %171, %164 ]
  %176 = add nsw i64 %174, -1
  %177 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %175, i64 1
  %tailaddr29 = bitcast %Ts28__ContiguousArrayStorageBaseC* %177 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %.element.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr29, i64 %176, i32 1, i32 1, i32 0
  %178 = load i64, i64* %.element.r._value, align 8
  %179 = icmp eq i64 %178, %139
  br i1 %179, label %182, label %._crit_edge

._crit_edge:                                      ; preds = %228, %.lr.ph, %164
  %180 = icmp eq i64 %139, %113
  br i1 %180, label %181, label %134

181:                                              ; preds = %._crit_edge
  call void @swift_release(%swift.refcounted* %120) #9
  br label %283

182:                                              ; preds = %.lr.ph
  %183 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %175, i64 0, i32 0
  %184 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %183) #27
  store %Ts28__ContiguousArrayStorageBaseC* %175, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  br i1 %184, label %187, label %185

185:                                              ; preds = %182
  %186 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi6offset_Si1l_Si1rt7elementt_Tg5"(%Ts28__ContiguousArrayStorageBaseC* nonnull %175)
  store %Ts28__ContiguousArrayStorageBaseC* %186, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  br label %187

187:                                              ; preds = %182, %185
  %188 = phi %Ts28__ContiguousArrayStorageBaseC* [ %186, %185 ], [ %175, %182 ]
  %._storage48.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %188, i64 0, i32 1, i32 0, i32 0, i32 0
  %189 = load i64, i64* %._storage48.count._value, align 8, !range !6
  %190 = icmp eq i64 %189, 0
  br i1 %190, label %357, label %191, !prof !7

191:                                              ; preds = %187
  %192 = add nsw i64 %189, -1
  %193 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %188, i64 1
  %tailaddr49 = bitcast %Ts28__ContiguousArrayStorageBaseC* %193 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %.offset._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr49, i64 %192, i32 0, i32 0
  %194 = load i64, i64* %.offset._value, align 8
  %.element50.l._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr49, i64 %192, i32 1, i32 0, i32 0
  %195 = load i64, i64* %.element50.l._value, align 8
  %.element50.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr49, i64 %192, i32 1, i32 1, i32 0
  %196 = load i64, i64* %.element50.r._value, align 8
  store i64 %192, i64* %._storage48.count._value, align 8
  store %Ts28__ContiguousArrayStorageBaseC* %188, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  %197 = load i64, i64* getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 1, i32 0), align 8
  %198 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 2, i32 0, i32 0), align 8
  %199 = load i8*, i8** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 0), align 8
  %200 = load %swift.refcounted*, %swift.refcounted** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 1), align 8
  %201 = load void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*, void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)** bitcast (i8** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 0) to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)**), align 8
  %202 = load %swift.refcounted*, %swift.refcounted** getelementptr inbounds (%T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* @"$s7llvm_OZ7counterAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 1), align 8
  %203 = icmp slt i64 %196, %195
  br i1 %203, label %358, label %204, !prof !7

204:                                              ; preds = %191
  %205 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %196, i64 -1)
  %206 = extractvalue { i64, i1 } %205, 0
  %207 = extractvalue { i64, i1 } %205, 1
  br i1 %207, label %359, label %208, !prof !7

208:                                              ; preds = %204
  %209 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %195, i64 -1)
  %210 = extractvalue { i64, i1 } %209, 0
  %211 = extractvalue { i64, i1 } %209, 1
  br i1 %211, label %360, label %212, !prof !7

212:                                              ; preds = %208
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %127)
  store i64 %197, i64* %._value52, align 8
  %213 = icmp slt i64 %206, 0
  br i1 %213, label %216, label %214

214:                                              ; preds = %212
  %215 = icmp slt i64 %210, 0
  br i1 %215, label %239, label %250

.sink.split:                                      ; preds = %277, %.loopexit, %241
  %.ph = phi i64 [ %249, %241 ], [ %270, %.loopexit ], [ %279, %277 ]
  call void @swift_release(%swift.refcounted* %202) #9
  call void @swift_release(%swift.refcounted* %200) #9
  %.sink = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 0
  call void @swift_release(%swift.refcounted* %.sink) #9
  br label %216

216:                                              ; preds = %.sink.split, %212
  %217 = phi i64 [ %197, %212 ], [ %.ph, %.sink.split ]
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %127)
  %218 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ9responsesSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  %219 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %218, i64 0, i32 0
  %220 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %219) #27
  store %Ts28__ContiguousArrayStorageBaseC* %218, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ9responsesSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  br i1 %220, label %223, label %221

221:                                              ; preds = %216
  %222 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSiSg_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %218)
  store %Ts28__ContiguousArrayStorageBaseC* %222, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ9responsesSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  br label %223

223:                                              ; preds = %216, %221
  %224 = phi %Ts28__ContiguousArrayStorageBaseC* [ %218, %216 ], [ %222, %221 ]
  %225 = icmp slt i64 %194, 0
  br i1 %225, label %361, label %226, !prof !7

226:                                              ; preds = %223
  %._storage53.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %224, i64 0, i32 1, i32 0, i32 0, i32 0
  %227 = load i64, i64* %._storage53.count._value, align 8, !range !6
  %.not112 = icmp ult i64 %194, %227
  br i1 %.not112, label %228, label %362, !prof !8

228:                                              ; preds = %226
  %229 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %224, i64 1
  %230 = bitcast %Ts28__ContiguousArrayStorageBaseC* %229 to i8*
  %231 = shl nsw i64 %194, 4
  %232 = getelementptr inbounds i8, i8* %230, i64 %231
  %233 = bitcast i8* %232 to i64*
  store i64 %217, i64* %233, align 1
  %234 = getelementptr inbounds i8, i8* %232, i64 8
  %235 = bitcast i8* %234 to i1*
  store i1 false, i1* %235, align 1
  %236 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ5queueSaySi6offset_Si1l_Si1rt7elementtGvp", i64 0, i32 0, i32 0), align 8
  %._storage28.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %236, i64 0, i32 1, i32 0, i32 0, i32 0
  %237 = load i64, i64* %._storage28.count._value, align 8, !range !6
  %238 = icmp eq i64 %237, 0
  br i1 %238, label %._crit_edge, label %.lr.ph

239:                                              ; preds = %214
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %128)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %129)
  %._storage67.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 1, i32 0, i32 0, i32 0
  %240 = load i64, i64* %._storage67.count._value, align 8, !range !6
  %.not115 = icmp eq i64 %240, 0
  br i1 %.not115, label %365, label %241, !prof !7

241:                                              ; preds = %239
  %242 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 1
  %tailaddr68._value = bitcast %Ts28__ContiguousArrayStorageBaseC* %242 to i64*
  %243 = load i64, i64* %tailaddr68._value, align 8
  store i64 %243, i64* %._value69, align 8
  %244 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 0
  %245 = bitcast i8* %199 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*
  %246 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %202) #27
  %247 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %244) #27
  %248 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %200) #27
  call swiftcc void %245(%TSi* noalias nocapture nonnull sret(%TSi) %12, %TSi* noalias nocapture nonnull dereferenceable(8) %7, %TSi* noalias nocapture nonnull dereferenceable(8) %13, %swift.refcounted* swiftself %200)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %129)
  %249 = load i64, i64* %._value70, align 8
  store i64 %249, i64* %._value52, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %128)
  %.not116 = icmp eq i64 %206, 0
  br i1 %.not116, label %.sink.split, label %256

250:                                              ; preds = %214
  %251 = icmp ult i64 %210, %206
  %252 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 0
  %253 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %252) #27
  %254 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %200) #27
  %255 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %202) #27
  br i1 %251, label %256, label %.loopexit

256:                                              ; preds = %250, %241
  %257 = phi i64 [ 0, %241 ], [ %210, %250 ]
  %.pre-phi = bitcast i8* %199 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*
  %258 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 1
  %tailaddr61 = bitcast %Ts28__ContiguousArrayStorageBaseC* %258 to %TSi*
  %._storage62.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 1, i32 0, i32 0, i32 0
  br label %259

259:                                              ; preds = %262, %256
  %260 = phi i64 [ %206, %256 ], [ %266, %262 ]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %130)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %131)
  %261 = load i64, i64* %._storage62.count._value, align 8, !range !6
  %.not114 = icmp slt i64 %260, %261
  br i1 %.not114, label %262, label %364, !prof !8

262:                                              ; preds = %259
  %._value63 = getelementptr inbounds %TSi, %TSi* %tailaddr61, i64 %260, i32 0
  %263 = load i64, i64* %._value63, align 8
  store i64 %263, i64* %._value64, align 8
  call swiftcc void %.pre-phi(%TSi* noalias nocapture nonnull sret(%TSi) %10, %TSi* noalias nocapture nonnull dereferenceable(8) %7, %TSi* noalias nocapture nonnull dereferenceable(8) %11, %swift.refcounted* swiftself %200)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %131)
  %264 = load i64, i64* %._value65, align 8
  store i64 %264, i64* %._value52, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %130)
  %265 = add nsw i64 %260, -1
  %266 = and i64 %265, %260
  %267 = icmp slt i64 %257, %266
  br i1 %267, label %259, label %.loopexit

.loopexit:                                        ; preds = %262, %250
  %268 = phi i64 [ %206, %250 ], [ %266, %262 ]
  %269 = phi i64 [ %210, %250 ], [ %257, %262 ]
  %270 = phi i64 [ %197, %250 ], [ %264, %262 ]
  %271 = icmp slt i64 %268, %269
  br i1 %271, label %272, label %.sink.split

272:                                              ; preds = %.loopexit
  %273 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 1
  %tailaddr55 = bitcast %Ts28__ContiguousArrayStorageBaseC* %273 to %TSi*
  %._storage56.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %198, i64 0, i32 1, i32 0, i32 0, i32 0
  br label %274

274:                                              ; preds = %277, %272
  %275 = phi i64 [ %269, %272 ], [ %281, %277 ]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %132)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %133)
  %276 = load i64, i64* %._storage56.count._value, align 8, !range !6
  %.not113 = icmp slt i64 %275, %276
  br i1 %.not113, label %277, label %363, !prof !8

277:                                              ; preds = %274
  %._value57 = getelementptr inbounds %TSi, %TSi* %tailaddr55, i64 %275, i32 0
  %278 = load i64, i64* %._value57, align 8
  store i64 %278, i64* %._value58, align 8
  call swiftcc void %201(%TSi* noalias nocapture nonnull sret(%TSi) %8, %TSi* noalias nocapture nonnull dereferenceable(8) %7, %TSi* noalias nocapture nonnull dereferenceable(8) %9, %swift.refcounted* swiftself %202)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %133)
  %279 = load i64, i64* %._value59, align 8
  store i64 %279, i64* %._value52, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %132)
  %280 = add nsw i64 %275, -1
  %281 = and i64 %280, %275
  %282 = icmp slt i64 %268, %281
  br i1 %282, label %274, label %.sink.split

283:                                              ; preds = %106, %181
  %284 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCyypGMD") #28
  %285 = call noalias %swift.refcounted* @swift_allocObject(%swift.type* %284, i64 64, i64 7) #9
  %286 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %285, i64 1
  %._storage30.count._value = bitcast %swift.refcounted* %286 to i64*
  store i64 1, i64* %._storage30.count._value, align 8
  %._storage30._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %285, i64 1, i32 1
  store i64 2, i64* %._storage30._capacityAndFlags, align 8
  %287 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch31, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %287)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_OZ9responsesSaySiSgGvp" to i8*), [24 x i8]* nonnull %access-scratch31, i64 0, i8* null) #9
  %288 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_OZ9responsesSaySiSgGvp", i64 0, i32 0, i32 0), align 8
  %._storage32.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %288, i64 0, i32 1, i32 0, i32 0, i32 0
  %289 = load i64, i64* %._storage32.count._value, align 8, !range !6
  %290 = icmp eq i64 %289, 0
  br i1 %290, label %299, label %291

291:                                              ; preds = %283
  %292 = bitcast %Ts15ContiguousArrayV* %4 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %292)
  %293 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %288, i64 0, i32 0
  %._buffer33._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %4, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** %._buffer33._storage, align 8
  %294 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %293) #27
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 false, i64 %289, i1 false, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %4)
  %295 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %288, i64 1
  %296 = bitcast %Ts28__ContiguousArrayStorageBaseC* %295 to i8*
  %297 = bitcast %TSi* %5 to i8*
  %._value37 = getelementptr inbounds %TSi, %TSi* %5, i64 0, i32 0
  %298 = bitcast %TSi* %5 to %swift.opaque*
  br label %314

299:                                              ; preds = %283, %346
  %300 = phi %Ts28__ContiguousArrayStorageBaseC* [ %343, %346 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %283 ]
  %301 = bitcast %swift.refcounted* %285 to %Ts28__ContiguousArrayStorageBaseC*
  %302 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %285, i64 2
  %303 = bitcast %TSa* %6 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %303)
  %._buffer45._storage = getelementptr inbounds %TSa, %TSa* %6, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %300, %Ts28__ContiguousArrayStorageBaseC** %._buffer45._storage, align 8
  %304 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$sSaySSGMD") #28
  %305 = call i8** @"$sSaySSGSayxGSKsWlTm"(i8*** @"$sSaySSGSayxGSKsWL", { i32, i32 }* @"$sSaySSGMD", %swift.protocol_conformance_descriptor* @"$sSayxGSKsMc")
  %306 = bitcast %TSa* %6 to %swift.opaque*
  %307 = call swiftcc { i64, %swift.bridge* } @"$sSKsSS7ElementRtzrlE6joined9separatorS2S_tF"(i64 10, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), %swift.type* %304, i8** %305, %swift.opaque* noalias nocapture nonnull swiftself %306)
  %308 = extractvalue { i64, %swift.bridge* } %307, 0
  %309 = extractvalue { i64, %swift.bridge* } %307, 1
  %310 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %300, i64 0, i32 0
  call void @swift_release(%swift.refcounted* %310) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %303)
  %311 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %285, i64 3, i32 1
  %312 = bitcast i64* %311 to %swift.type**
  store %swift.type* @"$sSSN", %swift.type** %312, align 8
  %._guts46._object._countAndFlagsBits._value = bitcast %swift.refcounted* %302 to i64*
  store i64 %308, i64* %._guts46._object._countAndFlagsBits._value, align 8
  %._guts46._object._object = getelementptr inbounds %swift.refcounted, %swift.refcounted* %285, i64 2, i32 1
  %313 = bitcast i64* %._guts46._object._object to %swift.bridge**
  store %swift.bridge* %309, %swift.bridge** %313, align 8
  call swiftcc void @"$ss5print_9separator10terminatoryypd_S2StF"(%Ts28__ContiguousArrayStorageBaseC* %301, i64 32, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), i64 10, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*))
  call void @swift_release(%swift.refcounted* %285) #9
  ret i32 0

314:                                              ; preds = %291, %342
  %315 = phi i64 [ 0, %291 ], [ %316, %342 ]
  %316 = add nuw nsw i64 %315, 1
  %317 = shl nsw i64 %315, 4
  %318 = getelementptr inbounds i8, i8* %296, i64 %317
  %319 = getelementptr inbounds i8, i8* %318, i64 8
  %320 = bitcast i8* %319 to i1*
  %321 = load i1, i1* %320, align 1
  br i1 %321, label %356, label %322

322:                                              ; preds = %314
  %323 = bitcast i8* %318 to i64*
  %324 = load i64, i64* %323, align 1
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %297)
  store i64 %324, i64* %._value37, align 8
  %325 = call swiftcc { i64, %swift.bridge* } @"$ss23CustomStringConvertibleP11descriptionSSvgTj"(%swift.opaque* noalias nocapture nonnull swiftself %298, %swift.type* nonnull @"$sSiN", i8** nonnull @"$sSis23CustomStringConvertiblesWP")
  %326 = extractvalue { i64, %swift.bridge* } %325, 0
  %327 = extractvalue { i64, %swift.bridge* } %325, 1
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %297)
  %328 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer33._storage, align 8
  %329 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %328, i64 0, i32 0
  %330 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %329) #27
  br i1 %330, label %334, label %331

331:                                              ; preds = %322
  %._storage39.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %328, i64 0, i32 1, i32 0, i32 0, i32 0
  %332 = load i64, i64* %._storage39.count._value, align 8, !range !6
  %333 = add nuw nsw i64 %332, 1
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 false, i64 %333, i1 true, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %4)
  %.pre129 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer33._storage, align 8
  br label %334

334:                                              ; preds = %322, %331
  %335 = phi %Ts28__ContiguousArrayStorageBaseC* [ %328, %322 ], [ %.pre129, %331 ]
  %._storage40.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %335, i64 0, i32 1, i32 0, i32 0, i32 0
  %336 = load i64, i64* %._storage40.count._value, align 8, !range !6
  %._storage40._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %335, i64 0, i32 1, i32 0, i32 1, i32 0
  %337 = load i64, i64* %._storage40._capacityAndFlags._value, align 8
  %338 = lshr i64 %337, 1
  %339 = add nuw nsw i64 %336, 1
  %.not111 = icmp ugt i64 %338, %336
  br i1 %.not111, label %342, label %340, !prof !8

340:                                              ; preds = %334
  %341 = icmp ugt i64 %337, 1
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 %341, i64 %339, i1 true, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %4)
  %.pre130 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer33._storage, align 8
  br label %342

342:                                              ; preds = %334, %340
  %343 = phi %Ts28__ContiguousArrayStorageBaseC* [ %335, %334 ], [ %.pre130, %340 ]
  %._storage41.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %343, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %339, i64* %._storage41.count._value, align 8
  %344 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %343, i64 1
  %tailaddr42 = bitcast %Ts28__ContiguousArrayStorageBaseC* %344 to %TSS*
  %._guts._object._countAndFlagsBits._value = getelementptr inbounds %TSS, %TSS* %tailaddr42, i64 %336, i32 0, i32 0, i32 0, i32 0
  store i64 %326, i64* %._guts._object._countAndFlagsBits._value, align 8
  %._guts._object._object = getelementptr inbounds %TSS, %TSS* %tailaddr42, i64 %336, i32 0, i32 0, i32 1
  store %swift.bridge* %327, %swift.bridge** %._guts._object._object, align 8
  %345 = icmp eq i64 %316, %289
  br i1 %345, label %346, label %314

346:                                              ; preds = %342
  call void @swift_release(%swift.refcounted* %293) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %292)
  br label %299

347:                                              ; preds = %31
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

348:                                              ; preds = %26
  call void asm sideeffect "", "n"(i32 2) #9
  call void @llvm.trap()
  unreachable

349:                                              ; preds = %.preheader
  call void asm sideeffect "", "n"(i32 3) #9
  call void @llvm.trap()
  unreachable

350:                                              ; preds = %69
  call void asm sideeffect "", "n"(i32 4) #9
  call void @llvm.trap()
  unreachable

351:                                              ; preds = %59
  call void asm sideeffect "", "n"(i32 6) #9
  call void @llvm.trap()
  unreachable

352:                                              ; preds = %134
  call void asm sideeffect "", "n"(i32 8) #9
  call void @llvm.trap()
  unreachable

353:                                              ; preds = %137
  call void asm sideeffect "", "n"(i32 10) #9
  call void @llvm.trap()
  unreachable

354:                                              ; preds = %142
  call void asm sideeffect "", "n"(i32 11) #9
  call void @llvm.trap()
  unreachable

355:                                              ; preds = %161
  call void asm sideeffect "", "n"(i32 12) #9
  call void @llvm.trap()
  unreachable

356:                                              ; preds = %314
  call void asm sideeffect "", "n"(i32 17) #9
  call void @llvm.trap()
  unreachable

357:                                              ; preds = %187
  call void asm sideeffect "", "n"(i32 20) #9
  call void @llvm.trap()
  unreachable

358:                                              ; preds = %191
  call void asm sideeffect "", "n"(i32 21) #9
  call void @llvm.trap()
  unreachable

359:                                              ; preds = %204
  call void asm sideeffect "", "n"(i32 22) #9
  call void @llvm.trap()
  unreachable

360:                                              ; preds = %208
  call void asm sideeffect "", "n"(i32 23) #9
  call void @llvm.trap()
  unreachable

361:                                              ; preds = %223
  call void asm sideeffect "", "n"(i32 24) #9
  call void @llvm.trap()
  unreachable

362:                                              ; preds = %226
  call void asm sideeffect "", "n"(i32 25) #9
  call void @llvm.trap()
  unreachable

363:                                              ; preds = %274
  call void asm sideeffect "", "n"(i32 27) #9
  call void @llvm.trap()
  unreachable

364:                                              ; preds = %259
  call void asm sideeffect "", "n"(i32 30) #9
  call void @llvm.trap()
  unreachable

365:                                              ; preds = %239
  call void asm sideeffect "", "n"(i32 32) #9
  call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc i8* @"$s7llvm_OZ12getsToBuffer4sizeSpys4Int8VGs5Int32V_tF"(i32 %0) local_unnamed_addr #0 {
entry:
  %access-scratch = alloca [24 x i8], align 8
  %access-scratch1 = alloca [24 x i8], align 8
  %access-scratch2 = alloca [24 x i8], align 8
  %1 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %1)
  call void @swift_beginAccess(i8* nonnull bitcast (%Ts5Int32V* @"$s7llvm_OZ14bufferCapacitys5Int32Vvp" to i8*), [24 x i8]* nonnull %access-scratch, i64 1, i8* null) #9
  %2 = load i32, i32* getelementptr inbounds (%Ts5Int32V, %Ts5Int32V* @"$s7llvm_OZ14bufferCapacitys5Int32Vvp", i64 0, i32 0), align 4
  %3 = icmp slt i32 %2, %0
  br i1 %3, label %4, label %14

4:                                                ; preds = %entry
  %5 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch2, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %5)
  call void @swift_beginAccess(i8* nonnull getelementptr inbounds (%TSpys4Int8VGSg, %TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch2, i64 1, i8* null) #9
  %6 = load i64, i64* bitcast (%TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp" to i64*), align 8
  %7 = icmp eq i64 %6, 0
  br i1 %7, label %10, label %8

8:                                                ; preds = %4
  %9 = inttoptr i64 %6 to i8*
  call void @swift_slowDealloc(i8* nonnull %9, i64 -1, i64 -1) #9
  br label %10

10:                                               ; preds = %4, %8
  %11 = sext i32 %0 to i64
  %12 = call noalias i8* @swift_slowAlloc(i64 %11, i64 -1) #9
  %13 = ptrtoint i8* %12 to i64
  store i64 %13, i64* bitcast (%TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp" to i64*), align 8
  store i32 %0, i32* getelementptr inbounds (%Ts5Int32V, %Ts5Int32V* @"$s7llvm_OZ14bufferCapacitys5Int32Vvp", i64 0, i32 0), align 4
  br label %14

14:                                               ; preds = %entry, %10
  %15 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch1, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %15)
  call void @swift_beginAccess(i8* nonnull getelementptr inbounds (%TSpys4Int8VGSg, %TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch1, i64 0, i8* null) #9
  %16 = load i64, i64* bitcast (%TSpys4Int8VGSg* @"$s7llvm_OZ6bufferSpys4Int8VGSgvp" to i64*), align 8
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %25, label %18

18:                                               ; preds = %14
  %19 = load i64, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_OZ5INPUTSpySo8_IO_FILEVGSgvp" to i64*), align 8
  %20 = inttoptr i64 %16 to i8*
  %21 = inttoptr i64 %19 to %struct._IO_FILE*
  %22 = call i8* @fgets(i8* nonnull %20, i32 %0, %struct._IO_FILE* %21)
  %23 = icmp eq i8* %22, null
  br i1 %23, label %26, label %24

24:                                               ; preds = %18
  ret i8* %22

25:                                               ; preds = %14
  call void asm sideeffect "", "n"(i32 0) #9
  call void @llvm.trap()
  unreachable

26:                                               ; preds = %18
  call void asm sideeffect "", "n"(i32 1) #9
  call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc i64 @"$s7llvm_OZ16getIntFromBufferySiSpys4Int8VGzF"(%TSp* noalias nocapture dereferenceable(8) %0) local_unnamed_addr #0 {
entry:
  %._rawValue = getelementptr inbounds %TSp, %TSp* %0, i64 0, i32 0
  %1 = bitcast %TSp* %0 to %Ts4Int8V**
  %.pre = load %Ts4Int8V*, %Ts4Int8V** %1, align 8
  br label %2

2:                                                ; preds = %33, %entry
  %3 = phi %Ts4Int8V* [ %.pre, %entry ], [ %38, %33 ]
  %4 = phi i64 [ 0, %entry ], [ %34, %33 ]
  %5 = phi i1 [ true, %entry ], [ %35, %33 ]
  %6 = phi i1 [ false, %entry ], [ %36, %33 ]
  %._value = getelementptr inbounds %Ts4Int8V, %Ts4Int8V* %3, i64 0, i32 0
  %7 = load i8, i8* %._value, align 1
  %8 = icmp eq i8 %7, 45
  br i1 %8, label %33, label %9

9:                                                ; preds = %2
  %10 = add i8 %7, -58
  %11 = icmp ult i8 %10, -10
  br i1 %11, label %25, label %12

12:                                               ; preds = %9
  %. = select i1 %5, i64 0, i64 %4
  %13 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %., i64 10)
  %14 = extractvalue { i64, i1 } %13, 1
  br i1 %14, label %39, label %15, !prof !7

15:                                               ; preds = %12
  %16 = extractvalue { i64, i1 } %13, 0
  %17 = zext i8 %7 to i64
  %18 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %16, i64 %17)
  %19 = extractvalue { i64, i1 } %18, 1
  br i1 %19, label %40, label %20, !prof !7

20:                                               ; preds = %15
  %21 = extractvalue { i64, i1 } %18, 0
  %22 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %21, i64 -48)
  %23 = extractvalue { i64, i1 } %22, 0
  %24 = extractvalue { i64, i1 } %22, 1
  br i1 %24, label %41, label %33, !prof !7

25:                                               ; preds = %9
  br i1 %5, label %33, label %26

26:                                               ; preds = %25
  br i1 %6, label %27, label %31

27:                                               ; preds = %26
  %28 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %4)
  %29 = extractvalue { i64, i1 } %28, 0
  %30 = extractvalue { i64, i1 } %28, 1
  br i1 %30, label %42, label %31, !prof !7

31:                                               ; preds = %26, %27
  %32 = phi i64 [ %29, %27 ], [ %4, %26 ]
  ret i64 %32

33:                                               ; preds = %25, %20, %2
  %34 = phi i64 [ %4, %2 ], [ %23, %20 ], [ %4, %25 ]
  %35 = phi i1 [ %5, %2 ], [ false, %20 ], [ true, %25 ]
  %36 = phi i1 [ true, %2 ], [ %6, %20 ], [ %6, %25 ]
  %37 = getelementptr inbounds %Ts4Int8V, %Ts4Int8V* %3, i64 1, i32 0
  store i8* %37, i8** %._rawValue, align 8
  %38 = bitcast i8* %37 to %Ts4Int8V*
  br label %2

39:                                               ; preds = %12
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

40:                                               ; preds = %15
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

41:                                               ; preds = %20
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

42:                                               ; preds = %27
  tail call void asm sideeffect "", "n"(i32 3) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc i64 @"$s7llvm_OZ6getIntSiyF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_OZ12getsToBuffer4sizeSpys4Int8VGs5Int32V_tF"(i32 24)
  %1 = bitcast i8* %0 to %Ts4Int8V*
  br label %2

2:                                                ; preds = %12, %entry
  %3 = phi i64 [ 0, %entry ], [ %13, %12 ]
  %4 = phi i1 [ true, %entry ], [ %14, %12 ]
  %5 = phi i1 [ false, %entry ], [ %15, %12 ]
  %6 = phi %Ts4Int8V* [ %1, %entry ], [ %16, %12 ]
  %._value = getelementptr inbounds %Ts4Int8V, %Ts4Int8V* %6, i64 0, i32 0
  %7 = load i8, i8* %._value, align 1
  %8 = icmp eq i8 %7, 45
  br i1 %8, label %12, label %9

9:                                                ; preds = %2
  %10 = add i8 %7, -58
  %11 = icmp ult i8 %10, -10
  br i1 %11, label %17, label %25

12:                                               ; preds = %33, %17, %2
  %13 = phi i64 [ %3, %2 ], [ %3, %17 ], [ %36, %33 ]
  %14 = phi i1 [ %4, %2 ], [ true, %17 ], [ false, %33 ]
  %15 = phi i1 [ true, %2 ], [ %5, %17 ], [ %5, %33 ]
  %16 = getelementptr inbounds %Ts4Int8V, %Ts4Int8V* %6, i64 1
  br label %2

17:                                               ; preds = %9
  br i1 %4, label %12, label %18

18:                                               ; preds = %17
  br i1 %5, label %19, label %23

19:                                               ; preds = %18
  %20 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %3)
  %21 = extractvalue { i64, i1 } %20, 0
  %22 = extractvalue { i64, i1 } %20, 1
  br i1 %22, label %41, label %23, !prof !7

23:                                               ; preds = %18, %19
  %24 = phi i64 [ %21, %19 ], [ %3, %18 ]
  ret i64 %24

25:                                               ; preds = %9
  %. = select i1 %4, i64 0, i64 %3
  %26 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %., i64 10)
  %27 = extractvalue { i64, i1 } %26, 1
  br i1 %27, label %38, label %28, !prof !7

28:                                               ; preds = %25
  %29 = extractvalue { i64, i1 } %26, 0
  %30 = zext i8 %7 to i64
  %31 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %29, i64 %30)
  %32 = extractvalue { i64, i1 } %31, 1
  br i1 %32, label %39, label %33, !prof !7

33:                                               ; preds = %28
  %34 = extractvalue { i64, i1 } %31, 0
  %35 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %34, i64 -48)
  %36 = extractvalue { i64, i1 } %35, 0
  %37 = extractvalue { i64, i1 } %35, 1
  br i1 %37, label %40, label %12, !prof !7

38:                                               ; preds = %25
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

39:                                               ; preds = %28
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

40:                                               ; preds = %33
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

41:                                               ; preds = %19
  tail call void asm sideeffect "", "n"(i32 3) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc { i64, i64 } @"$s7llvm_OZ10getIntPairSi_SityF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_OZ12getsToBuffer4sizeSpys4Int8VGs5Int32V_tF"(i32 48)
  br label %1

1:                                                ; preds = %11, %entry
  %2 = phi i64 [ 0, %entry ], [ %12, %11 ]
  %3 = phi i1 [ true, %entry ], [ %13, %11 ]
  %4 = phi i1 [ false, %entry ], [ %14, %11 ]
  %5 = phi i8* [ %0, %entry ], [ %15, %11 ]
  %6 = load i8, i8* %5, align 1
  %7 = icmp eq i8 %6, 45
  br i1 %7, label %11, label %8

8:                                                ; preds = %1
  %9 = add i8 %6, -58
  %10 = icmp ult i8 %9, -10
  br i1 %10, label %16, label %24

11:                                               ; preds = %32, %16, %1
  %12 = phi i64 [ %2, %1 ], [ %2, %16 ], [ %35, %32 ]
  %13 = phi i1 [ %3, %1 ], [ true, %16 ], [ false, %32 ]
  %14 = phi i1 [ true, %1 ], [ %4, %16 ], [ %4, %32 ]
  %15 = getelementptr inbounds i8, i8* %5, i64 1
  br label %1

16:                                               ; preds = %8
  br i1 %3, label %11, label %17

17:                                               ; preds = %16
  br i1 %4, label %18, label %22

18:                                               ; preds = %17
  %19 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %2)
  %20 = extractvalue { i64, i1 } %19, 0
  %21 = extractvalue { i64, i1 } %19, 1
  br i1 %21, label %82, label %22, !prof !7

22:                                               ; preds = %17, %18
  %23 = phi i64 [ %20, %18 ], [ %2, %17 ]
  br label %37

24:                                               ; preds = %8
  %. = select i1 %3, i64 0, i64 %2
  %25 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %., i64 10)
  %26 = extractvalue { i64, i1 } %25, 1
  br i1 %26, label %75, label %27, !prof !7

27:                                               ; preds = %24
  %28 = extractvalue { i64, i1 } %25, 0
  %29 = zext i8 %6 to i64
  %30 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %28, i64 %29)
  %31 = extractvalue { i64, i1 } %30, 1
  br i1 %31, label %76, label %32, !prof !7

32:                                               ; preds = %27
  %33 = extractvalue { i64, i1 } %30, 0
  %34 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %33, i64 -48)
  %35 = extractvalue { i64, i1 } %34, 0
  %36 = extractvalue { i64, i1 } %34, 1
  br i1 %36, label %77, label %11, !prof !7

37:                                               ; preds = %47, %22
  %38 = phi i8 [ %6, %22 ], [ %.pre, %47 ]
  %39 = phi i64 [ 0, %22 ], [ %48, %47 ]
  %40 = phi i1 [ true, %22 ], [ %49, %47 ]
  %41 = phi i1 [ false, %22 ], [ %50, %47 ]
  %42 = phi i8* [ %5, %22 ], [ %51, %47 ]
  %43 = icmp eq i8 %38, 45
  br i1 %43, label %47, label %44

44:                                               ; preds = %37
  %45 = add i8 %38, -58
  %46 = icmp ult i8 %45, -10
  br i1 %46, label %52, label %62

47:                                               ; preds = %70, %52, %37
  %48 = phi i64 [ %39, %37 ], [ %39, %52 ], [ %73, %70 ]
  %49 = phi i1 [ %40, %37 ], [ true, %52 ], [ false, %70 ]
  %50 = phi i1 [ true, %37 ], [ %41, %52 ], [ %41, %70 ]
  %51 = getelementptr inbounds i8, i8* %42, i64 1
  %.pre = load i8, i8* %51, align 1
  br label %37

52:                                               ; preds = %44
  br i1 %40, label %47, label %53

53:                                               ; preds = %52
  br i1 %41, label %54, label %58

54:                                               ; preds = %53
  %55 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %39)
  %56 = extractvalue { i64, i1 } %55, 0
  %57 = extractvalue { i64, i1 } %55, 1
  br i1 %57, label %81, label %58, !prof !7

58:                                               ; preds = %53, %54
  %59 = phi i64 [ %56, %54 ], [ %39, %53 ]
  %60 = insertvalue { i64, i64 } undef, i64 %23, 0
  %61 = insertvalue { i64, i64 } %60, i64 %59, 1
  ret { i64, i64 } %61

62:                                               ; preds = %44
  %.2 = select i1 %40, i64 0, i64 %39
  %63 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.2, i64 10)
  %64 = extractvalue { i64, i1 } %63, 1
  br i1 %64, label %78, label %65, !prof !7

65:                                               ; preds = %62
  %66 = extractvalue { i64, i1 } %63, 0
  %67 = zext i8 %38 to i64
  %68 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %66, i64 %67)
  %69 = extractvalue { i64, i1 } %68, 1
  br i1 %69, label %79, label %70, !prof !7

70:                                               ; preds = %65
  %71 = extractvalue { i64, i1 } %68, 0
  %72 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %71, i64 -48)
  %73 = extractvalue { i64, i1 } %72, 0
  %74 = extractvalue { i64, i1 } %72, 1
  br i1 %74, label %80, label %47, !prof !7

75:                                               ; preds = %24
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

76:                                               ; preds = %27
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

77:                                               ; preds = %32
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

78:                                               ; preds = %62
  tail call void asm sideeffect "", "n"(i32 3) #9
  tail call void @llvm.trap()
  unreachable

79:                                               ; preds = %65
  tail call void asm sideeffect "", "n"(i32 4) #9
  tail call void @llvm.trap()
  unreachable

80:                                               ; preds = %70
  tail call void asm sideeffect "", "n"(i32 5) #9
  tail call void @llvm.trap()
  unreachable

81:                                               ; preds = %54
  tail call void asm sideeffect "", "n"(i32 6) #9
  tail call void @llvm.trap()
  unreachable

82:                                               ; preds = %18
  tail call void asm sideeffect "", "n"(i32 7) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$s7llvm_OZ7getInts5countSaySiGSi_tF"(i64 %0) local_unnamed_addr #0 {
entry:
  %1 = icmp slt i64 %0, -2147483648
  br i1 %1, label %69, label %2, !prof !7

2:                                                ; preds = %entry
  %3 = icmp sgt i64 %0, 2147483647
  br i1 %3, label %70, label %4, !prof !7

4:                                                ; preds = %2
  %5 = trunc i64 %0 to i32
  %6 = tail call { i32, i1 } @llvm.smul.with.overflow.i32(i32 %5, i32 24)
  %7 = extractvalue { i32, i1 } %6, 1
  br i1 %7, label %71, label %8, !prof !7

8:                                                ; preds = %4
  %9 = extractvalue { i32, i1 } %6, 0
  %10 = tail call swiftcc i8* @"$s7llvm_OZ12getsToBuffer4sizeSpys4Int8VGs5Int32V_tF"(i32 %9)
  %11 = tail call i64 @llvm.smax.i64(i64 %0, i64 0)
  %12 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 false, i64 %11, i1 false, %Ts28__ContiguousArrayStorageBaseC* nonnull bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*))
  %13 = icmp slt i64 %0, 0
  br i1 %13, label %72, label %14, !prof !7

14:                                               ; preds = %8
  %15 = icmp eq i64 %0, 0
  br i1 %15, label %.loopexit, label %.preheader

.preheader:                                       ; preds = %14, %51
  %16 = phi i64 [ %20, %51 ], [ 0, %14 ]
  %17 = phi i8* [ %25, %51 ], [ %10, %14 ]
  %18 = phi %Ts28__ContiguousArrayStorageBaseC* [ %52, %51 ], [ %12, %14 ]
  %exitcond.not = icmp eq i64 %16, %0
  br i1 %exitcond.not, label %73, label %19, !prof !7

19:                                               ; preds = %.preheader
  %20 = add nuw nsw i64 %16, 1
  br label %21

21:                                               ; preds = %19, %31
  %22 = phi i64 [ %32, %31 ], [ 0, %19 ]
  %23 = phi i1 [ %33, %31 ], [ true, %19 ]
  %24 = phi i1 [ %34, %31 ], [ false, %19 ]
  %25 = phi i8* [ %35, %31 ], [ %17, %19 ]
  %26 = load i8, i8* %25, align 1
  %27 = icmp eq i8 %26, 45
  br i1 %27, label %31, label %28

28:                                               ; preds = %21
  %29 = add i8 %26, -58
  %30 = icmp ult i8 %29, -10
  br i1 %30, label %36, label %55

31:                                               ; preds = %63, %36, %21
  %32 = phi i64 [ %22, %21 ], [ %22, %36 ], [ %66, %63 ]
  %33 = phi i1 [ %23, %21 ], [ true, %36 ], [ false, %63 ]
  %34 = phi i1 [ true, %21 ], [ %24, %36 ], [ %24, %63 ]
  %35 = getelementptr inbounds i8, i8* %25, i64 1
  br label %21

36:                                               ; preds = %28
  br i1 %23, label %31, label %37

37:                                               ; preds = %36
  br i1 %24, label %38, label %42

38:                                               ; preds = %37
  %39 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %22)
  %40 = extractvalue { i64, i1 } %39, 0
  %41 = extractvalue { i64, i1 } %39, 1
  br i1 %41, label %77, label %42, !prof !7

42:                                               ; preds = %37, %38
  %43 = phi i64 [ %40, %38 ], [ %22, %37 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 1, i32 0, i32 0, i32 0
  %44 = load i64, i64* %._storage.count._value, align 8, !range !6
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 1, i32 0, i32 1, i32 0
  %45 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %46 = lshr i64 %45, 1
  %47 = add nuw nsw i64 %44, 1
  %.not = icmp ugt i64 %46, %44
  br i1 %.not, label %51, label %48, !prof !8

48:                                               ; preds = %42
  %49 = icmp ugt i64 %45, 1
  %50 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 %49, i64 %47, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull %18)
  br label %51

51:                                               ; preds = %42, %48
  %52 = phi %Ts28__ContiguousArrayStorageBaseC* [ %50, %48 ], [ %18, %42 ]
  %._storage1.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %52, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %47, i64* %._storage1.count._value, align 8
  %53 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %52, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %53 to %TSi*
  %._value2 = getelementptr inbounds %TSi, %TSi* %tailaddr, i64 %44, i32 0
  store i64 %43, i64* %._value2, align 8
  %54 = icmp eq i64 %20, %0
  br i1 %54, label %.loopexit, label %.preheader

55:                                               ; preds = %28
  %.3 = select i1 %23, i64 0, i64 %22
  %56 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.3, i64 10)
  %57 = extractvalue { i64, i1 } %56, 1
  br i1 %57, label %74, label %58, !prof !7

58:                                               ; preds = %55
  %59 = extractvalue { i64, i1 } %56, 0
  %60 = zext i8 %26 to i64
  %61 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %59, i64 %60)
  %62 = extractvalue { i64, i1 } %61, 1
  br i1 %62, label %75, label %63, !prof !7

63:                                               ; preds = %58
  %64 = extractvalue { i64, i1 } %61, 0
  %65 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %64, i64 -48)
  %66 = extractvalue { i64, i1 } %65, 0
  %67 = extractvalue { i64, i1 } %65, 1
  br i1 %67, label %76, label %31, !prof !7

.loopexit:                                        ; preds = %51, %14
  %68 = phi %Ts28__ContiguousArrayStorageBaseC* [ %12, %14 ], [ %52, %51 ]
  ret %Ts28__ContiguousArrayStorageBaseC* %68

69:                                               ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

70:                                               ; preds = %2
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

71:                                               ; preds = %4
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

72:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 3) #9
  tail call void @llvm.trap()
  unreachable

73:                                               ; preds = %.preheader
  tail call void asm sideeffect "", "n"(i32 4) #9
  tail call void @llvm.trap()
  unreachable

74:                                               ; preds = %55
  tail call void asm sideeffect "", "n"(i32 6) #9
  tail call void @llvm.trap()
  unreachable

75:                                               ; preds = %58
  tail call void asm sideeffect "", "n"(i32 7) #9
  tail call void @llvm.trap()
  unreachable

76:                                               ; preds = %63
  tail call void asm sideeffect "", "n"(i32 8) #9
  tail call void @llvm.trap()
  unreachable

77:                                               ; preds = %38
  tail call void asm sideeffect "", "n"(i32 9) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: argmemonly mustprogress nocallback nofree nosync nounwind willreturn
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$sSa15reserveCapacityyySiFSi1l_Si1rt_Tg5"(i64 %0, %TSa* nocapture swiftself dereferenceable(8) %1) local_unnamed_addr #0 {
entry:
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %1, i64 0, i32 0, i32 0
  %2 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %3 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %2, i64 0, i32 0
  %4 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %3) #27
  br i1 %4, label %5, label %9

5:                                                ; preds = %entry
  %._storage2._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %2, i64 0, i32 1, i32 0, i32 1, i32 0
  %6 = load i64, i64* %._storage2._capacityAndFlags._value, align 8
  %7 = lshr i64 %6, 1
  %8 = icmp slt i64 %7, %0
  br i1 %8, label %9, label %13, !prof !7

9:                                                ; preds = %5, %entry
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %2, i64 0, i32 1, i32 0, i32 0, i32 0
  %10 = load i64, i64* %._storage.count._value, align 8, !range !6
  %11 = tail call i64 @llvm.smax.i64(i64 %10, i64 %0)
  %12 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi1l_Si1rt_Tg5"(i1 %4, i64 %11, i1 false, %Ts28__ContiguousArrayStorageBaseC* %2)
  br label %13

13:                                               ; preds = %5, %9
  %14 = phi %Ts28__ContiguousArrayStorageBaseC* [ %12, %9 ], [ %2, %5 ]
  store %Ts28__ContiguousArrayStorageBaseC* %14, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  ret void
}

; Function Attrs: minsize mustprogress nofree norecurse nosync nounwind optsize readnone willreturn
define hidden swiftcc i64 @"$s7llvm_OZ10scanString9maxLengthSSSi_tFfA_"() local_unnamed_addr #2 {
entry:
  ret i64 255
}

; Function Attrs: minsize optsize sspreq
define hidden swiftcc { i64, %swift.bridge* } @"$s7llvm_OZ10scanString9maxLengthSSSi_tF"(i64 %0) local_unnamed_addr #3 {
entry:
  %reference.raw14 = alloca [72 x i8], align 8
  %reference.raw1 = alloca %Ts15__VaListBuilderC, align 8
  %1 = alloca %TSS, align 8
  %2 = alloca %TSi, align 8
  %3 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %0, i64 1)
  %4 = extractvalue { i64, i1 } %3, 1
  br i1 %4, label %68, label %5, !prof !7

5:                                                ; preds = %entry
  %6 = extractvalue { i64, i1 } %3, 0
  %7 = tail call noalias i8* @swift_slowAlloc(i64 %6, i64 -1) #9
  %8 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCys7CVarArg_pGMD") #28
  %9 = bitcast [72 x i8]* %reference.raw14 to %swift.refcounted*
  %reference.new = call %swift.refcounted* @swift_initStackObject(%swift.type* %8, %swift.refcounted* nonnull %9) #27
  %10 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new, i64 1
  %._storage.count._value = bitcast %swift.refcounted* %10 to i64*
  store i64 1, i64* %._storage.count._value, align 8
  %._storage._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new, i64 1, i32 1
  store i64 2, i64* %._storage._capacityAndFlags, align 8
  %11 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new, i64 2
  %12 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$sSpys4Int8VGMD") #28
  %13 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new, i64 3, i32 1
  %14 = bitcast i64* %13 to %swift.type**
  store %swift.type* %12, %swift.type** %14, align 8
  %15 = call i8** @"$sSaySSGSayxGSKsWlTm"(i8*** @"$sSpys4Int8VGSpyxGs7CVarArgsWL", { i32, i32 }* @"$sSpys4Int8VGMD", %swift.protocol_conformance_descriptor* @"$sSpyxGs7CVarArgsMc")
  %16 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new, i64 4
  %17 = bitcast %swift.refcounted* %16 to i8***
  store i8** %15, i8*** %17, align 8
  %._rawValue = bitcast %swift.refcounted* %11 to i8**
  store i8* %7, i8** %._rawValue, align 8
  %18 = call swiftcc %swift.metadata_response @"$ss15__VaListBuilderCMa"(i64 0) #29
  %19 = extractvalue %swift.metadata_response %18, 0
  %20 = getelementptr inbounds %Ts15__VaListBuilderC, %Ts15__VaListBuilderC* %reference.raw1, i64 0, i32 0
  %reference.new2 = call %swift.refcounted* @swift_initStackObject(%swift.type* %19, %swift.refcounted* nonnull %20) #27
  %21 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 1
  %22 = bitcast %swift.refcounted* %21 to i8*
  call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(16) %22, i8 0, i64 16, i1 false)
  %23 = call swiftcc i64 @"$ss17_countGPRegistersSivg"()
  %24 = shl i64 %23, 3
  %25 = add i64 %23, -1152921504606846976
  %26 = icmp ult i64 %25, -2305843009213693952
  br i1 %26, label %69, label %27, !prof !7

27:                                               ; preds = %5
  %28 = icmp slt i64 %24, 0
  br i1 %28, label %70, label %29, !prof !7

29:                                               ; preds = %27
  %30 = icmp ugt i64 %24, 4294967295
  br i1 %30, label %71, label %31, !prof !7

31:                                               ; preds = %29
  %32 = bitcast %swift.refcounted* %reference.new2 to %Ts15__VaListBuilderC*
  %33 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 2
  %34 = bitcast %swift.refcounted* %33 to %Ts15__VaListBuilderC6HeaderV*
  %tailaddr = bitcast %swift.refcounted* %11 to %Ts7CVarArgP*
  %35 = bitcast %swift.refcounted* %reference.new to %Ts23_ContiguousArrayStorageCys7CVarArg_pG*
  %36 = trunc i64 %24 to i32
  %.gp_offset._value = bitcast %swift.refcounted* %33 to i32*
  store i32 0, i32* %.gp_offset._value, align 8
  %.fp_offset._value = getelementptr inbounds %Ts15__VaListBuilderC6HeaderV, %Ts15__VaListBuilderC6HeaderV* %34, i64 0, i32 1, i32 0
  store i32 %36, i32* %.fp_offset._value, align 4
  %.overflow_arg_area = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 2, i32 1
  %.reg_save_area = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 3
  %37 = bitcast %swift.refcounted* %.reg_save_area to i64*
  %38 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 4
  %._buffer._storage = bitcast %swift.refcounted* %38 to %Ts28__ContiguousArrayStorageBaseC**
  %39 = bitcast i64* %.overflow_arg_area to i8*
  call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(16) %39, i8 0, i64 16, i1 false)
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %40 = call swiftcc i64 @"$ss18_registerSaveWordsSivg"()
  %41 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss15ContiguousArrayV9repeating5countAByxGx_SitcfCSi_Tgq5"(i64 0, i64 %40)
  %42 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %reference.new2, i64 3, i32 1
  %._buffer4._storage = bitcast i64* %42 to %Ts28__ContiguousArrayStorageBaseC**
  store %Ts28__ContiguousArrayStorageBaseC* %41, %Ts28__ContiguousArrayStorageBaseC** %._buffer4._storage, align 8
  call swiftcc void @"$ss15__VaListBuilderC6appendyys7CVarArg_pF"(%Ts7CVarArgP* noalias nocapture nonnull dereferenceable(40) %tailaddr, %Ts15__VaListBuilderC* swiftself %32)
  %43 = bitcast i64* %42 to i8**
  %44 = load i8*, i8** %43, align 8
  %45 = getelementptr inbounds i8, i8* %44, i64 32
  %tailaddr7 = bitcast i8* %45 to %TSi*
  %46 = ptrtoint i8* %45 to i64
  store i64 %46, i64* %37, align 8
  %47 = getelementptr inbounds %TSi, %TSi* %tailaddr7, i64 %40
  %48 = ptrtoint %TSi* %47 to i64
  store i64 %48, i64* %.overflow_arg_area, align 8
  %49 = load i64, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_OZ5INPUTSpySo8_IO_FILEVGSgvp" to i64*), align 8
  %50 = bitcast %TSS* %1 to i8*
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %50)
  %._guts._object._countAndFlagsBits._value = getelementptr inbounds %TSS, %TSS* %1, i64 0, i32 0, i32 0, i32 0, i32 0
  store i64 37, i64* %._guts._object._countAndFlagsBits._value, align 8
  %._guts._object._object = getelementptr inbounds %TSS, %TSS* %1, i64 0, i32 0, i32 0, i32 1
  store %swift.bridge* inttoptr (i64 -2233785415175766016 to %swift.bridge*), %swift.bridge** %._guts._object._object, align 8
  %51 = bitcast %TSi* %2 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %51)
  %._value10 = getelementptr inbounds %TSi, %TSi* %2, i64 0, i32 0
  store i64 %0, i64* %._value10, align 8
  %52 = bitcast %TSi* %2 to %swift.opaque*
  %53 = call swiftcc { i64, %swift.bridge* } @"$ss23CustomStringConvertibleP11descriptionSSvgTj"(%swift.opaque* noalias nocapture nonnull swiftself %52, %swift.type* nonnull @"$sSiN", i8** nonnull @"$sSis23CustomStringConvertiblesWP")
  %54 = extractvalue { i64, %swift.bridge* } %53, 0
  %55 = extractvalue { i64, %swift.bridge* } %53, 1
  call swiftcc void @"$sSS6appendyySSF"(i64 %54, %swift.bridge* %55, %TSS* nocapture nonnull swiftself dereferenceable(16) %1)
  call void @swift_bridgeObjectRelease(%swift.bridge* %55) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %51)
  call swiftcc void @"$sSS6appendyySSF"(i64 115, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), %TSS* nocapture nonnull swiftself dereferenceable(16) %1)
  %56 = load i64, i64* %._guts._object._countAndFlagsBits._value, align 8
  %57 = load %swift.bridge*, %swift.bridge** %._guts._object._object, align 8
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %50)
  %58 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSS11utf8CStrings15ContiguousArrayVys4Int8VGvg"(i64 %56, %swift.bridge* %57)
  call void @swift_bridgeObjectRelease(%swift.bridge* %57) #9
  %59 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %58, i64 1
  %60 = bitcast %Ts28__ContiguousArrayStorageBaseC* %59 to i8*
  %61 = inttoptr i64 %49 to %struct._IO_FILE*
  %62 = bitcast %swift.refcounted* %33 to %struct.__va_list_tag*
  %63 = call i32 @__isoc99_vfscanf(%struct._IO_FILE* %61, i8* nonnull %60, %struct.__va_list_tag* nonnull %62)
  %64 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %58, i64 0, i32 0
  call void @swift_release(%swift.refcounted* %64) #9
  call void @swift_setDeallocating(%swift.refcounted* nonnull %reference.new2) #9
  call swiftcc void @"$ss15__VaListBuilderCfD"(%Ts15__VaListBuilderC* swiftself %32)
  %65 = bitcast %swift.refcounted* %reference.new2 to i8*
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %65)
  call void @swift_setDeallocating(%swift.refcounted* nonnull %reference.new) #9
  call swiftcc void @"$ss23_ContiguousArrayStorageCfDs7CVarArg_p_Tg5"(%Ts23_ContiguousArrayStorageCys7CVarArg_pG* swiftself %35)
  %66 = bitcast %swift.refcounted* %reference.new to i8*
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %66)
  %67 = call swiftcc { i64, %swift.bridge* } @"$sSS7cStringSSSPys4Int8VG_tcfC"(i8* %7)
  ret { i64, %swift.bridge* } %67

68:                                               ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

69:                                               ; preds = %5
  call void asm sideeffect "", "n"(i32 1) #9
  call void @llvm.trap()
  unreachable

70:                                               ; preds = %27
  call void asm sideeffect "", "n"(i32 2) #9
  call void @llvm.trap()
  unreachable

71:                                               ; preds = %29
  call void asm sideeffect "", "n"(i32 3) #9
  call void @llvm.trap()
  unreachable
}

; Function Attrs: argmemonly minsize mustprogress nofree norecurse nosync nounwind optsize readonly willreturn
define hidden swiftcc i64 @"$s7llvm_OZ11FenwickTreeV5countSivg"(%swift.type* nocapture readnone %"FenwickTree<Element>", %T7llvm_OZ11FenwickTreeV* noalias nocapture readonly swiftself %0) local_unnamed_addr #4 {
entry:
  %.count._value = getelementptr inbounds %T7llvm_OZ11FenwickTreeV, %T7llvm_OZ11FenwickTreeV* %0, i64 0, i32 0, i32 0
  %1 = load i64, i64* %.count._value, align 8
  ret i64 %1
}

; Function Attrs: minsize optsize
define hidden swiftcc void @"$s7llvm_OZ11FenwickTreeV5count12defaultValue5addBy06removeI0ACyxGSi_xxx_xtcxx_xtctcfC"(%swift.opaque* noalias nocapture sret(%swift.opaque) %0, i64 %1, %swift.opaque* noalias nocapture %2, i8* %3, %swift.refcounted* %4, i8* %5, %swift.refcounted* %6, %swift.type* %Element) local_unnamed_addr #0 {
entry:
  %7 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %8 = bitcast %swift.type* %7 to i8***
  %Element.valueWitnesses = load i8**, i8*** %8, align 8, !invariant.load !9, !dereferenceable !10
  %9 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %10 = bitcast i8** %9 to i64*
  %size = load i64, i64* %10, align 8, !invariant.load !9
  %11 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %11)
  %12 = bitcast i8* %11 to %swift.opaque*
  %13 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 2
  %14 = bitcast i8** %13 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %15 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %14, align 8, !invariant.load !9
  %16 = call %swift.opaque* %15(%swift.opaque* noalias nonnull %12, %swift.opaque* noalias %2, %swift.type* %Element) #9
  %17 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfC"(%swift.opaque* noalias nocapture nonnull %12, i64 %1, %swift.type* %Element)
  %18 = call swiftcc %swift.metadata_response @"$s7llvm_OZ11FenwickTreeVMa"(i64 0, %swift.type* %Element) #29
  %19 = extractvalue %swift.metadata_response %18, 0
  %20 = bitcast %swift.type* %19 to i32*
  %21 = getelementptr inbounds %swift.type, %swift.type* %19, i64 4
  %22 = bitcast %swift.type* %21 to i32*
  %23 = load i32, i32* %22, align 8
  %24 = bitcast %swift.opaque* %0 to i8*
  %25 = sext i32 %23 to i64
  %26 = getelementptr inbounds i8, i8* %24, i64 %25
  %.tree._buffer._storage = bitcast i8* %26 to %Ts28__ContiguousArrayStorageBaseC**
  store %Ts28__ContiguousArrayStorageBaseC* %17, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  %.count._value = bitcast %swift.opaque* %0 to i64*
  store i64 %1, i64* %.count._value, align 8
  %27 = getelementptr inbounds i32, i32* %20, i64 7
  %28 = load i32, i32* %27, align 8
  %29 = sext i32 %28 to i64
  %30 = getelementptr inbounds i8, i8* %24, i64 %29
  %.defaultValue = bitcast i8* %30 to %swift.opaque*
  %31 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %32 = bitcast i8** %31 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %33 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %32, align 8, !invariant.load !9
  %34 = call %swift.opaque* %33(%swift.opaque* noalias %.defaultValue, %swift.opaque* noalias %2, %swift.type* %Element) #9
  %35 = getelementptr inbounds i32, i32* %20, i64 9
  %36 = load i32, i32* %35, align 8
  %37 = sext i32 %36 to i64
  %38 = getelementptr inbounds i8, i8* %24, i64 %37
  %.combine.fn = bitcast i8* %38 to i8**
  store i8* %3, i8** %.combine.fn, align 8
  %.combine.data = getelementptr inbounds i8, i8* %38, i64 8
  %39 = bitcast i8* %.combine.data to %swift.refcounted**
  store %swift.refcounted* %4, %swift.refcounted** %39, align 8
  %40 = getelementptr inbounds %swift.type, %swift.type* %19, i64 5
  %41 = bitcast %swift.type* %40 to i32*
  %42 = load i32, i32* %41, align 8
  %43 = sext i32 %42 to i64
  %44 = getelementptr inbounds i8, i8* %24, i64 %43
  %.inverse.fn = bitcast i8* %44 to i8**
  store i8* %5, i8** %.inverse.fn, align 8
  %.inverse.data = getelementptr inbounds i8, i8* %44, i64 8
  %45 = bitcast i8* %.inverse.data to %swift.refcounted**
  store %swift.refcounted* %6, %swift.refcounted** %45, align 8
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %11)
  ret void
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCSiSg_Tg5"(i64 %0, i8 %1, i64 %2) local_unnamed_addr #0 {
entry:
  %3 = and i8 %1, 1
  %4 = icmp ne i8 %3, 0
  %5 = icmp slt i64 %2, 0
  br i1 %5, label %22, label %6, !prof !7

6:                                                ; preds = %entry
  %.not = icmp eq i64 %2, 0
  br i1 %.not, label %.thread, label %7

7:                                                ; preds = %6
  %8 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$sSiSgMD") #28
  %9 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64 %2, %swift.type* %8)
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %9, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %2, i64* %._storage.count._value, align 8
  %10 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %9, i64 1
  %11 = bitcast %Ts28__ContiguousArrayStorageBaseC* %10 to i8*
  br label %13

.thread:                                          ; preds = %13, %6
  %12 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %6 ], [ %9, %13 ]
  ret %Ts28__ContiguousArrayStorageBaseC* %12

13:                                               ; preds = %13, %7
  %14 = phi i8* [ %21, %13 ], [ %11, %7 ]
  %15 = phi i64 [ %16, %13 ], [ 0, %7 ]
  %16 = add nuw nsw i64 %15, 1
  %17 = bitcast i8* %14 to i64*
  store i64 %0, i64* %17, align 8
  %18 = getelementptr inbounds i8, i8* %14, i64 8
  %19 = bitcast i8* %18 to i1*
  store i1 %4, i1* %19, align 8
  %20 = icmp eq i64 %16, %2
  %21 = getelementptr inbounds i8, i8* %14, i64 16
  br i1 %20, label %.thread, label %13

22:                                               ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCSi_Tg5"(i64 %0, i64 %1) local_unnamed_addr #0 {
entry:
  %2 = icmp slt i64 %1, 0
  br i1 %2, label %15, label %3, !prof !7

3:                                                ; preds = %entry
  %.not = icmp eq i64 %1, 0
  br i1 %.not, label %.thread, label %4

4:                                                ; preds = %3
  %5 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64 %1, %swift.type* nonnull @"$sSiN")
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %5, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %1, i64* %._storage.count._value, align 8
  %6 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %5, i64 1
  %7 = bitcast %Ts28__ContiguousArrayStorageBaseC* %6 to %TSi*
  br label %9

.thread:                                          ; preds = %9, %3
  %8 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %3 ], [ %5, %9 ]
  ret %Ts28__ContiguousArrayStorageBaseC* %8

9:                                                ; preds = %9, %4
  %10 = phi %TSi* [ %14, %9 ], [ %7, %4 ]
  %11 = phi i64 [ %12, %9 ], [ 0, %4 ]
  %12 = add nuw nsw i64 %11, 1
  %._value = getelementptr inbounds %TSi, %TSi* %10, i64 0, i32 0
  store i64 %0, i64* %._value, align 8
  %13 = icmp eq i64 %12, %1
  %14 = getelementptr inbounds %TSi, %TSi* %10, i64 1
  br i1 %13, label %.thread, label %9

15:                                               ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
declare swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfC"(%swift.opaque* noalias nocapture, i64, %swift.type*) local_unnamed_addr #0

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$s7llvm_OZ11FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %0, i64 %1, %T7llvm_OZ11FenwickTreeVySiG* nocapture swiftself dereferenceable(56) %2) local_unnamed_addr #0 {
entry:
  %3 = alloca %TSi, align 8
  %4 = alloca %TSi, align 8
  %5 = alloca %TSi, align 8
  %6 = alloca %TSi, align 8
  %7 = alloca %TSi, align 8
  %8 = bitcast %TSi* %3 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %8)
  %._value = getelementptr inbounds %TSi, %TSi* %3, i64 0, i32 0
  store i64 %1, i64* %._value, align 8
  %9 = icmp eq i64 %0, 0
  %.combine8 = getelementptr inbounds %T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* %2, i64 0, i32 3
  %.tree9._buffer._storage = getelementptr inbounds %T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* %2, i64 0, i32 2, i32 0, i32 0
  br i1 %9, label %10, label %32

10:                                               ; preds = %entry
  %11 = bitcast %swift.function* %.combine8 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)**
  %12 = load void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*, void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)** %11, align 8
  %.combine8.data = getelementptr inbounds %T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* %2, i64 0, i32 3, i32 1
  %13 = load %swift.refcounted*, %swift.refcounted** %.combine8.data, align 8
  %14 = bitcast %TSi* %6 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %14)
  %15 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree9._buffer._storage, align 8
  %16 = bitcast %TSi* %7 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %16)
  %._storage10.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %15, i64 0, i32 1, i32 0, i32 0, i32 0
  %17 = load i64, i64* %._storage10.count._value, align 8, !range !6
  %.not20 = icmp eq i64 %17, 0
  br i1 %.not20, label %71, label %18, !prof !7

18:                                               ; preds = %10
  %19 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %15, i64 1
  %tailaddr11._value = bitcast %Ts28__ContiguousArrayStorageBaseC* %19 to i64*
  %20 = load i64, i64* %tailaddr11._value, align 8
  %._value12 = getelementptr inbounds %TSi, %TSi* %7, i64 0, i32 0
  store i64 %20, i64* %._value12, align 8
  %21 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %13) #27
  call swiftcc void %12(%TSi* noalias nocapture nonnull sret(%TSi) %6, %TSi* noalias nocapture nonnull dereferenceable(8) %7, %TSi* noalias nocapture nonnull dereferenceable(8) %3, %swift.refcounted* swiftself %13)
  tail call void @swift_release(%swift.refcounted* %13) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %16)
  %22 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %15, i64 0, i32 0
  %23 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %22) #27
  br i1 %23, label %26, label %24

24:                                               ; preds = %18
  %25 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi_Tg5"(%Ts28__ContiguousArrayStorageBaseC* nonnull %15)
  br label %26

26:                                               ; preds = %18, %24
  %27 = phi %Ts28__ContiguousArrayStorageBaseC* [ %25, %24 ], [ %15, %18 ]
  %._storage13.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %27, i64 0, i32 1, i32 0, i32 0, i32 0
  %28 = load i64, i64* %._storage13.count._value, align 8, !range !6
  %.not21 = icmp eq i64 %28, 0
  br i1 %.not21, label %72, label %29, !prof !7

29:                                               ; preds = %26
  %30 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %27, i64 1
  %._value15 = getelementptr inbounds %TSi, %TSi* %6, i64 0, i32 0
  %31 = load i64, i64* %._value15, align 8
  %tailaddr14._value = bitcast %Ts28__ContiguousArrayStorageBaseC* %30 to i64*
  store i64 %31, i64* %tailaddr14._value, align 8
  store %Ts28__ContiguousArrayStorageBaseC* %27, %Ts28__ContiguousArrayStorageBaseC** %.tree9._buffer._storage, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %14)
  br label %47

32:                                               ; preds = %entry
  %.count._value = getelementptr inbounds %T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* %2, i64 0, i32 0, i32 0
  %33 = bitcast %swift.function* %.combine8 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)**
  %34 = load void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*, void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)** %33, align 8
  %.combine.data = getelementptr inbounds %T7llvm_OZ11FenwickTreeVySiG, %T7llvm_OZ11FenwickTreeVySiG* %2, i64 0, i32 3, i32 1
  %35 = load %swift.refcounted*, %swift.refcounted** %.combine.data, align 8
  %36 = load i64, i64* %.count._value, align 8
  %37 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree9._buffer._storage, align 8
  %38 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %37, i64 0, i32 0
  %39 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %38) #27
  br i1 %39, label %42, label %40

40:                                               ; preds = %32
  %41 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %37)
  br label %42

42:                                               ; preds = %32, %40
  %43 = phi %Ts28__ContiguousArrayStorageBaseC* [ %41, %40 ], [ %37, %32 ]
  %44 = bitcast %TSi* %4 to i8*
  %45 = bitcast %TSi* %5 to i8*
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %43, i64 0, i32 1, i32 0, i32 0, i32 0
  %46 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %43, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %46 to %TSi*
  %._value2 = getelementptr inbounds %TSi, %TSi* %5, i64 0, i32 0
  %._value5 = getelementptr inbounds %TSi, %TSi* %4, i64 0, i32 0
  br label %48

47:                                               ; preds = %29, %66
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %8)
  ret void

48:                                               ; preds = %63, %42
  %49 = phi i64 [ %0, %42 ], [ %64, %63 ]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %44)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %45)
  %50 = icmp slt i64 %49, 0
  br i1 %50, label %67, label %51, !prof !7

51:                                               ; preds = %48
  %52 = load i64, i64* %._storage.count._value, align 8, !range !6
  %.not = icmp ult i64 %49, %52
  br i1 %.not, label %53, label %68, !prof !8

53:                                               ; preds = %51
  %._value1 = getelementptr inbounds %TSi, %TSi* %tailaddr, i64 %49, i32 0
  %54 = load i64, i64* %._value1, align 8
  store i64 %54, i64* %._value2, align 8
  %55 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %35) #27
  call swiftcc void %34(%TSi* noalias nocapture nonnull sret(%TSi) %4, %TSi* noalias nocapture nonnull dereferenceable(8) %5, %TSi* noalias nocapture nonnull dereferenceable(8) %3, %swift.refcounted* swiftself %35)
  tail call void @swift_release(%swift.refcounted* %35) #9
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %45)
  %56 = load i64, i64* %._storage.count._value, align 8, !range !6
  %.not19 = icmp ult i64 %49, %56
  br i1 %.not19, label %57, label %69, !prof !8

57:                                               ; preds = %53
  %58 = load i64, i64* %._value5, align 8
  store i64 %58, i64* %._value1, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %44)
  %59 = sub nsw i64 0, %49
  %60 = and i64 %49, %59
  %61 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %49, i64 %60)
  %62 = extractvalue { i64, i1 } %61, 1
  br i1 %62, label %70, label %63, !prof !7

63:                                               ; preds = %57
  %64 = extractvalue { i64, i1 } %61, 0
  %65 = icmp slt i64 %64, %36
  br i1 %65, label %48, label %66

66:                                               ; preds = %63
  store %Ts28__ContiguousArrayStorageBaseC* %43, %Ts28__ContiguousArrayStorageBaseC** %.tree9._buffer._storage, align 8
  br label %47

67:                                               ; preds = %48
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

68:                                               ; preds = %51
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

69:                                               ; preds = %53
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

70:                                               ; preds = %57
  tail call void asm sideeffect "", "n"(i32 4) #9
  tail call void @llvm.trap()
  unreachable

71:                                               ; preds = %10
  tail call void asm sideeffect "", "n"(i32 5) #9
  tail call void @llvm.trap()
  unreachable

72:                                               ; preds = %26
  tail call void asm sideeffect "", "n"(i32 6) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define hidden swiftcc void @"$s7llvm_OZ11FenwickTreeV6update2at6addingySi_xtF"(i64 %0, %swift.opaque* noalias nocapture %1, %swift.type* nocapture readonly %"FenwickTree<Element>", %T7llvm_OZ11FenwickTreeV* nocapture swiftself %2) local_unnamed_addr #0 {
entry:
  %3 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %4 = bitcast %swift.type* %3 to %swift.type**
  %Element = load %swift.type*, %swift.type** %4, align 8, !invariant.load !9
  %5 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %6 = bitcast %swift.type* %5 to i8***
  %Element.valueWitnesses = load i8**, i8*** %6, align 8, !invariant.load !9, !dereferenceable !10
  %7 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %8 = bitcast i8** %7 to i64*
  %size = load i64, i64* %8, align 8, !invariant.load !9
  %9 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %9)
  %10 = bitcast i8* %9 to %swift.opaque*
  %11 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %11)
  %12 = bitcast i8* %11 to %swift.opaque*
  %13 = icmp eq i64 %0, 0
  %14 = bitcast %swift.type* %"FenwickTree<Element>" to i32*
  %15 = getelementptr inbounds i32, i32* %14, i64 9
  %16 = load i32, i32* %15, align 8
  %17 = bitcast %T7llvm_OZ11FenwickTreeV* %2 to i8*
  %18 = sext i32 %16 to i64
  %19 = getelementptr inbounds i8, i8* %17, i64 %18
  br i1 %13, label %20, label %52

20:                                               ; preds = %entry
  %21 = bitcast i8* %19 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %22 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %21, align 8
  %.combine2.data = getelementptr inbounds i8, i8* %19, i64 8
  %23 = bitcast i8* %.combine2.data to %swift.refcounted**
  %24 = load %swift.refcounted*, %swift.refcounted** %23, align 8
  %25 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %26 = bitcast %swift.type* %25 to i32*
  %27 = load i32, i32* %26, align 8
  %28 = sext i32 %27 to i64
  %29 = getelementptr inbounds i8, i8* %17, i64 %28
  %.tree3 = bitcast i8* %29 to %TSa*
  %.tree3._buffer._storage = bitcast i8* %29 to %Ts28__ContiguousArrayStorageBaseC**
  %30 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree3._buffer._storage, align 8
  %31 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %24) #27
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %10, i64 0, %Ts28__ContiguousArrayStorageBaseC* %30, %swift.type* nonnull %Element)
  call swiftcc void %22(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %12, %swift.opaque* noalias nocapture nonnull %10, %swift.opaque* noalias nocapture %1, %swift.refcounted* swiftself %24)
  %32 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %33 = bitcast i8** %32 to void (%swift.opaque*, %swift.type*)**
  %34 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %33, align 8, !invariant.load !9
  call void %34(%swift.opaque* noalias nonnull %10, %swift.type* nonnull %Element) #9
  call void @swift_release(%swift.refcounted* %24) #9
  %35 = call swiftcc %swift.metadata_response @"$sSaMa"(i64 0, %swift.type* nonnull %Element) #29
  %36 = extractvalue %swift.metadata_response %35, 0
  call swiftcc void @"$sSa21_makeMutableAndUniqueyyF"(%swift.type* %36, %TSa* nocapture swiftself dereferenceable(8) %.tree3)
  %37 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree3._buffer._storage, align 8
  %._storage.count._value.i = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %37, i64 0, i32 1, i32 0, i32 0, i32 0
  %38 = load i64, i64* %._storage.count._value.i, align 8, !range !6
  %.not.i.not = icmp eq i64 %38, 0
  br i1 %.not.i.not, label %39, label %"$sSa24_checkSubscript_mutatingyySiF.exit", !prof !7

39:                                               ; preds = %20
  call void asm sideeffect "", "n"(i32 1) #9
  call void @llvm.trap()
  unreachable

"$sSa24_checkSubscript_mutatingyySiF.exit":       ; preds = %20
  %40 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %41 = bitcast i8** %40 to i32*
  %flags6 = load i32, i32* %41, align 8, !invariant.load !9
  %42 = and i32 %flags6, 255
  %flags6.alignmentMask = zext i32 %42 to i64
  %43 = add nuw nsw i64 %flags6.alignmentMask, 32
  %44 = xor i64 %flags6.alignmentMask, -1
  %45 = and i64 %43, %44
  %46 = bitcast %Ts28__ContiguousArrayStorageBaseC* %37 to i8*
  %47 = getelementptr inbounds i8, i8* %46, i64 %45
  %tailaddr7 = bitcast i8* %47 to %swift.opaque*
  %48 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 5
  %49 = bitcast i8** %48 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %50 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %49, align 8, !invariant.load !9
  %51 = call %swift.opaque* %50(%swift.opaque* noalias %tailaddr7, %swift.opaque* noalias nonnull %12, %swift.type* nonnull %Element) #9
  br label %.loopexit

52:                                               ; preds = %entry
  %53 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %54 = bitcast %swift.type* %53 to i32*
  %55 = load i32, i32* %54, align 8
  %56 = sext i32 %55 to i64
  %57 = getelementptr inbounds i8, i8* %17, i64 %56
  %.tree = bitcast i8* %57 to %TSa*
  %.count._value = getelementptr inbounds %T7llvm_OZ11FenwickTreeV, %T7llvm_OZ11FenwickTreeV* %2, i64 0, i32 0, i32 0
  %58 = bitcast i8* %19 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %.combine.data = getelementptr inbounds i8, i8* %19, i64 8
  %59 = bitcast i8* %.combine.data to %swift.refcounted**
  %.tree._buffer._storage = bitcast i8* %57 to %Ts28__ContiguousArrayStorageBaseC**
  %60 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %61 = bitcast i8** %60 to void (%swift.opaque*, %swift.type*)**
  %62 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %63 = bitcast i8** %62 to i32*
  %64 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 9
  %65 = bitcast i8** %64 to i64*
  %66 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 5
  %67 = bitcast i8** %66 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  br label %68

68:                                               ; preds = %96, %52
  %69 = phi i64 [ %0, %52 ], [ %97, %96 ]
  %70 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %58, align 8
  %71 = load %swift.refcounted*, %swift.refcounted** %59, align 8
  %72 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  %73 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %71) #27
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %10, i64 %69, %Ts28__ContiguousArrayStorageBaseC* %72, %swift.type* %Element)
  call swiftcc void %70(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %12, %swift.opaque* noalias nocapture nonnull %10, %swift.opaque* noalias nocapture %1, %swift.refcounted* swiftself %71)
  %74 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %61, align 8, !invariant.load !9
  call void %74(%swift.opaque* noalias nonnull %10, %swift.type* %Element) #9
  call void @swift_release(%swift.refcounted* %71) #9
  %75 = call swiftcc %swift.metadata_response @"$sSaMa"(i64 0, %swift.type* %Element) #29
  %76 = extractvalue %swift.metadata_response %75, 0
  call swiftcc void @"$sSa21_makeMutableAndUniqueyyF"(%swift.type* %76, %TSa* nocapture swiftself dereferenceable(8) %.tree)
  %77 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  call swiftcc void @"$sSa24_checkSubscript_mutatingyySiF"(i64 %69, %Ts28__ContiguousArrayStorageBaseC* %77, %swift.type* %Element)
  %flags = load i32, i32* %63, align 8, !invariant.load !9
  %78 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %78 to i64
  %79 = add nuw nsw i64 %flags.alignmentMask, 32
  %80 = xor i64 %flags.alignmentMask, -1
  %81 = and i64 %79, %80
  %82 = bitcast %Ts28__ContiguousArrayStorageBaseC* %77 to i8*
  %83 = getelementptr inbounds i8, i8* %82, i64 %81
  %stride = load i64, i64* %65, align 8, !invariant.load !9
  %84 = mul nsw i64 %stride, %69
  %85 = getelementptr inbounds i8, i8* %83, i64 %84
  %86 = bitcast i8* %85 to %swift.opaque*
  %87 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %67, align 8, !invariant.load !9
  %88 = call %swift.opaque* %87(%swift.opaque* noalias %86, %swift.opaque* noalias nonnull %12, %swift.type* %Element) #9
  %89 = call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %69)
  %90 = extractvalue { i64, i1 } %89, 1
  br i1 %90, label %100, label %91, !prof !7

91:                                               ; preds = %68
  %92 = extractvalue { i64, i1 } %89, 0
  %93 = and i64 %92, %69
  %94 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %69, i64 %93)
  %95 = extractvalue { i64, i1 } %94, 1
  br i1 %95, label %101, label %96, !prof !7

96:                                               ; preds = %91
  %97 = extractvalue { i64, i1 } %94, 0
  %98 = load i64, i64* %.count._value, align 8
  %99 = icmp slt i64 %97, %98
  br i1 %99, label %68, label %.loopexit

.loopexit:                                        ; preds = %96, %"$sSa24_checkSubscript_mutatingyySiF.exit"
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %11)
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %9)
  ret void

100:                                              ; preds = %68
  call void asm sideeffect "", "n"(i32 0) #9
  call void @llvm.trap()
  unreachable

101:                                              ; preds = %91
  call void asm sideeffect "", "n"(i32 1) #9
  call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
declare swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture sret(%swift.opaque), i64, %Ts28__ContiguousArrayStorageBaseC*, %swift.type*) local_unnamed_addr #0

; Function Attrs: minsize optsize
define hidden swiftcc void @"$s7llvm_OZ11FenwickTreeV5query5rangexSnySiG_tF"(%swift.opaque* noalias nocapture sret(%swift.opaque) %0, i64 %1, i64 %2, %swift.type* nocapture readonly %"FenwickTree<Element>", %T7llvm_OZ11FenwickTreeV* noalias nocapture swiftself %3) local_unnamed_addr #0 {
entry:
  %4 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %5 = bitcast %swift.type* %4 to %swift.type**
  %Element = load %swift.type*, %swift.type** %5, align 8, !invariant.load !9
  %6 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %7 = bitcast %swift.type* %6 to i8***
  %Element.valueWitnesses = load i8**, i8*** %7, align 8, !invariant.load !9, !dereferenceable !10
  %8 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %9 = bitcast i8** %8 to i64*
  %size = load i64, i64* %9, align 8, !invariant.load !9
  %10 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %10)
  %11 = bitcast i8* %10 to %swift.opaque*
  %12 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %12)
  %13 = bitcast i8* %12 to %swift.opaque*
  %14 = alloca i8, i64 %size, align 16
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %14)
  %15 = bitcast i8* %14 to %swift.opaque*
  %16 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %2, i64 -1)
  %17 = extractvalue { i64, i1 } %16, 0
  %18 = extractvalue { i64, i1 } %16, 1
  br i1 %18, label %127, label %19, !prof !7

19:                                               ; preds = %entry
  %20 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %1, i64 -1)
  %21 = extractvalue { i64, i1 } %20, 0
  %22 = extractvalue { i64, i1 } %20, 1
  br i1 %22, label %128, label %23, !prof !7

23:                                               ; preds = %19
  %24 = bitcast %swift.type* %"FenwickTree<Element>" to i32*
  %25 = getelementptr inbounds i32, i32* %24, i64 7
  %26 = load i32, i32* %25, align 8
  %27 = bitcast %T7llvm_OZ11FenwickTreeV* %3 to i8*
  %28 = sext i32 %26 to i64
  %29 = getelementptr inbounds i8, i8* %27, i64 %28
  %.defaultValue = bitcast i8* %29 to %swift.opaque*
  %30 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 2
  %31 = bitcast i8** %30 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %32 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %31, align 8, !invariant.load !9
  %33 = call %swift.opaque* %32(%swift.opaque* noalias nonnull %15, %swift.opaque* noalias %.defaultValue, %swift.type* nonnull %Element) #9
  %34 = icmp slt i64 %17, 0
  br i1 %34, label %35, label %40

35:                                               ; preds = %23
  %36 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %37 = bitcast i8** %36 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %38 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %37, align 8, !invariant.load !9
  %39 = call %swift.opaque* %38(%swift.opaque* noalias %0, %swift.opaque* noalias nonnull %15, %swift.type* nonnull %Element) #9
  br label %126

40:                                               ; preds = %23
  %41 = icmp slt i64 %21, 0
  br i1 %41, label %42, label %64

42:                                               ; preds = %40
  %43 = getelementptr inbounds i32, i32* %24, i64 9
  %44 = load i32, i32* %43, align 8
  %45 = sext i32 %44 to i64
  %46 = getelementptr inbounds i8, i8* %27, i64 %45
  %47 = bitcast i8* %46 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %48 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %47, align 8
  %.combine5.data = getelementptr inbounds i8, i8* %46, i64 8
  %49 = bitcast i8* %.combine5.data to %swift.refcounted**
  %50 = load %swift.refcounted*, %swift.refcounted** %49, align 8
  %51 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %52 = bitcast %swift.type* %51 to i32*
  %53 = load i32, i32* %52, align 8
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds i8, i8* %27, i64 %54
  %.tree6._buffer._storage = bitcast i8* %55 to %Ts28__ContiguousArrayStorageBaseC**
  %56 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree6._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 0, %Ts28__ContiguousArrayStorageBaseC* %56, %swift.type* nonnull %Element)
  call swiftcc void %48(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture nonnull %15, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %50)
  %57 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %58 = bitcast i8** %57 to void (%swift.opaque*, %swift.type*)**
  %59 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %58, align 8, !invariant.load !9
  call void %59(%swift.opaque* noalias nonnull %11, %swift.type* nonnull %Element) #9
  call void %59(%swift.opaque* noalias nonnull %15, %swift.type* nonnull %Element) #9
  %60 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %61 = bitcast i8** %60 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %62 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %61, align 8, !invariant.load !9
  %63 = call %swift.opaque* %62(%swift.opaque* noalias nonnull %15, %swift.opaque* noalias nonnull %13, %swift.type* nonnull %Element) #9
  %.not = icmp eq i64 %17, 0
  br i1 %.not, label %.loopexit, label %._crit_edge

64:                                               ; preds = %40
  %65 = icmp ult i64 %21, %17
  br i1 %65, label %._crit_edge, label %.loopexit16

._crit_edge:                                      ; preds = %64, %42
  %66 = phi i64 [ 0, %42 ], [ %21, %64 ]
  %67 = getelementptr inbounds i32, i32* %24, i64 9
  %68 = load i32, i32* %67, align 8
  %69 = sext i32 %68 to i64
  %70 = getelementptr inbounds i8, i8* %27, i64 %69
  %71 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %72 = bitcast %swift.type* %71 to i32*
  %73 = load i32, i32* %72, align 8
  %74 = sext i32 %73 to i64
  %75 = getelementptr inbounds i8, i8* %27, i64 %74
  %76 = bitcast i8* %70 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %.combine.data = getelementptr inbounds i8, i8* %70, i64 8
  %77 = bitcast i8* %.combine.data to %swift.refcounted**
  %.tree2._buffer._storage = bitcast i8* %75 to %Ts28__ContiguousArrayStorageBaseC**
  %78 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %79 = bitcast i8** %78 to void (%swift.opaque*, %swift.type*)**
  %80 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %81 = bitcast i8** %80 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  br label %82

82:                                               ; preds = %82, %._crit_edge
  %83 = phi i64 [ %17, %._crit_edge ], [ %91, %82 ]
  %84 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %76, align 8
  %85 = load %swift.refcounted*, %swift.refcounted** %77, align 8
  %86 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree2._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 %83, %Ts28__ContiguousArrayStorageBaseC* %86, %swift.type* %Element)
  call swiftcc void %84(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture nonnull %15, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %85)
  %87 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %79, align 8, !invariant.load !9
  call void %87(%swift.opaque* noalias nonnull %11, %swift.type* %Element) #9
  call void %87(%swift.opaque* noalias nonnull %15, %swift.type* %Element) #9
  %88 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %81, align 8, !invariant.load !9
  %89 = call %swift.opaque* %88(%swift.opaque* noalias nonnull %15, %swift.opaque* noalias nonnull %13, %swift.type* %Element) #9
  %90 = add nsw i64 %83, -1
  %91 = and i64 %90, %83
  %92 = icmp slt i64 %66, %91
  br i1 %92, label %82, label %.loopexit16

.loopexit16:                                      ; preds = %82, %64
  %93 = phi i64 [ %17, %64 ], [ %91, %82 ]
  %94 = phi i64 [ %21, %64 ], [ %66, %82 ]
  %95 = icmp slt i64 %93, %94
  br i1 %95, label %96, label %.loopexit16..loopexit_crit_edge

.loopexit16..loopexit_crit_edge:                  ; preds = %.loopexit16
  %.phi.trans.insert = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %.phi.trans.insert17 = bitcast i8** %.phi.trans.insert to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %.pre = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %.phi.trans.insert17, align 8, !invariant.load !9
  br label %.loopexit

96:                                               ; preds = %.loopexit16
  %97 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 5
  %98 = bitcast %swift.type* %97 to i32*
  %99 = load i32, i32* %98, align 8
  %100 = sext i32 %99 to i64
  %101 = getelementptr inbounds i8, i8* %27, i64 %100
  %102 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %103 = bitcast %swift.type* %102 to i32*
  %104 = load i32, i32* %103, align 8
  %105 = sext i32 %104 to i64
  %106 = getelementptr inbounds i8, i8* %27, i64 %105
  %107 = bitcast i8* %101 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %.inverse.data = getelementptr inbounds i8, i8* %101, i64 8
  %108 = bitcast i8* %.inverse.data to %swift.refcounted**
  %.tree._buffer._storage = bitcast i8* %106 to %Ts28__ContiguousArrayStorageBaseC**
  %109 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %110 = bitcast i8** %109 to void (%swift.opaque*, %swift.type*)**
  %111 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %112 = bitcast i8** %111 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  br label %113

113:                                              ; preds = %113, %96
  %114 = phi i64 [ %94, %96 ], [ %122, %113 ]
  %115 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %107, align 8
  %116 = load %swift.refcounted*, %swift.refcounted** %108, align 8
  %117 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 %114, %Ts28__ContiguousArrayStorageBaseC* %117, %swift.type* %Element)
  call swiftcc void %115(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture nonnull %15, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %116)
  %118 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %110, align 8, !invariant.load !9
  call void %118(%swift.opaque* noalias nonnull %11, %swift.type* %Element) #9
  call void %118(%swift.opaque* noalias nonnull %15, %swift.type* %Element) #9
  %119 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %112, align 8, !invariant.load !9
  %120 = call %swift.opaque* %119(%swift.opaque* noalias nonnull %15, %swift.opaque* noalias nonnull %13, %swift.type* %Element) #9
  %121 = add nsw i64 %114, -1
  %122 = and i64 %121, %114
  %123 = icmp slt i64 %93, %122
  br i1 %123, label %113, label %.loopexit

.loopexit:                                        ; preds = %113, %.loopexit16..loopexit_crit_edge, %42
  %124 = phi %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* [ %.pre, %.loopexit16..loopexit_crit_edge ], [ %62, %42 ], [ %119, %113 ]
  %125 = call %swift.opaque* %124(%swift.opaque* noalias %0, %swift.opaque* noalias nonnull %15, %swift.type* %Element) #9
  br label %126

126:                                              ; preds = %35, %.loopexit
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %14)
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %12)
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %10)
  ret void

127:                                              ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

128:                                              ; preds = %19
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define internal swiftcc void @"$s7llvm_OZS2i_Sitcfu1_"(%TSi* noalias nocapture writeonly sret(%TSi) %0, %TSi* noalias nocapture readonly dereferenceable(8) %1, %TSi* noalias nocapture readonly dereferenceable(8) %2) #0 {
entry:
  %._value = getelementptr inbounds %TSi, %TSi* %1, i64 0, i32 0
  %3 = load i64, i64* %._value, align 8
  %._value1 = getelementptr inbounds %TSi, %TSi* %2, i64 0, i32 0
  %4 = load i64, i64* %._value1, align 8
  %5 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %3, i64 %4)
  %6 = extractvalue { i64, i1 } %5, 1
  br i1 %6, label %9, label %7, !prof !7

7:                                                ; preds = %entry
  %8 = extractvalue { i64, i1 } %5, 0
  %._value2 = getelementptr inbounds %TSi, %TSi* %0, i64 0, i32 0
  store i64 %8, i64* %._value2, align 8
  ret void

9:                                                ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define internal swiftcc void @"$s7llvm_OZS2i_Sitcfu2_"(%TSi* noalias nocapture writeonly sret(%TSi) %0, %TSi* noalias nocapture readonly dereferenceable(8) %1, %TSi* noalias nocapture readonly dereferenceable(8) %2) #0 {
entry:
  %._value = getelementptr inbounds %TSi, %TSi* %1, i64 0, i32 0
  %3 = load i64, i64* %._value, align 8
  %._value1 = getelementptr inbounds %TSi, %TSi* %2, i64 0, i32 0
  %4 = load i64, i64* %._value1, align 8
  %5 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %3, i64 %4)
  %6 = extractvalue { i64, i1 } %5, 1
  br i1 %6, label %9, label %7, !prof !7

7:                                                ; preds = %entry
  %8 = extractvalue { i64, i1 } %5, 0
  %._value2 = getelementptr inbounds %TSi, %TSi* %0, i64 0, i32 0
  store i64 %8, i64* %._value2, align 8
  ret void

9:                                                ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$sSMsSkRzrlE4sort2byySb7ElementSTQz_ADtKXE_tKFs15ContiguousArrayVySi6offset_Si1l_Si1rt7elementtG_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_m3AC_M13ADtAEttXEfU0_Tf1cn_n"(%Ts15ContiguousArrayV* nocapture dereferenceable(8) %0, %swift.refcounted* swiftself %1, %swift.error** noalias nocapture swifterror dereferenceable(8) %2) local_unnamed_addr #0 {
entry:
  %3 = alloca %TSrySi6offset_Si1l_Si1rt7elementtG, align 8
  %._buffer._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %0, i64 0, i32 0, i32 0
  %4 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %5 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %4, i64 0, i32 0
  %6 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %5) #27
  br i1 %6, label %common.ret, label %7

7:                                                ; preds = %entry
  %8 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi6offset_Si1l_Si1rt7elementt_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %4)
  br label %common.ret

common.ret:                                       ; preds = %entry, %7
  %9 = phi %Ts28__ContiguousArrayStorageBaseC* [ %8, %7 ], [ %4, %entry ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %9, i64 0, i32 1, i32 0, i32 0, i32 0
  %10 = load i64, i64* %._storage.count._value, align 8, !range !6
  %11 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %9, i64 1
  %12 = getelementptr inbounds %TSrySi6offset_Si1l_Si1rt7elementtG, %TSrySi6offset_Si1l_Si1rt7elementtG* %3, i64 0, i32 0, i32 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %12)
  %13 = ptrtoint %Ts28__ContiguousArrayStorageBaseC* %11 to i64
  %14 = bitcast %TSrySi6offset_Si1l_Si1rt7elementtG* %3 to i64*
  store i64 %13, i64* %14, align 8
  %.count._value = getelementptr inbounds %TSrySi6offset_Si1l_Si1rt7elementtG, %TSrySi6offset_Si1l_Si1rt7elementtG* %3, i64 0, i32 1, i32 0
  store i64 %10, i64* %.count._value, align 8
  call swiftcc void @"$sSr15_stableSortImpl2byySbx_xtKXE_tKFSi6offset_Si1l_Si1rt7elementt_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_l3AC_L13ADtAEttXEfU0_Tf1cn_n"(%TSrySi6offset_Si1l_Si1rt7elementtG* nocapture nonnull dereferenceable(16) %3, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture nonnull swifterror dereferenceable(8) %2)
  store %Ts28__ContiguousArrayStorageBaseC* %9, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %12)
  ret void
}

; Function Attrs: minsize optsize
declare swiftcc void @"$sSa21_makeMutableAndUniqueyyF"(%swift.type*, %TSa* nocapture swiftself dereferenceable(8)) local_unnamed_addr #0

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$sSa24_checkSubscript_mutatingyySiF"(i64 %0, %Ts28__ContiguousArrayStorageBaseC* %1, %swift.type* %Element) local_unnamed_addr #0 {
entry:
  %2 = icmp slt i64 %0, 0
  br i1 %2, label %6, label %3, !prof !7

3:                                                ; preds = %entry
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %1, i64 0, i32 1, i32 0, i32 0, i32 0
  %4 = load i64, i64* %._storage.count._value, align 8, !range !6
  %.not = icmp ugt i64 %4, %0
  br i1 %.not, label %5, label %7, !prof !8

5:                                                ; preds = %3
  ret void

6:                                                ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

7:                                                ; preds = %3
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi6offset_Si1l_Si1rt7elementt_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #5 {
entry:
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._storage.count._value, align 8, !range !6
  %2 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi6offset_Si1l_Si1rt7elementt_Tg5"(i1 false, i64 %1, i1 false, %Ts28__ContiguousArrayStorageBaseC* %0)
  ret %Ts28__ContiguousArrayStorageBaseC* %2
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSiSg_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #5 {
entry:
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._storage.count._value, align 8, !range !6
  %2 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSiSg_Tg5"(i1 false, i64 %1, i1 false, %Ts28__ContiguousArrayStorageBaseC* %0)
  ret %Ts28__ContiguousArrayStorageBaseC* %2
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #5 {
entry:
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._storage.count._value, align 8, !range !6
  %2 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 false, i64 %1, i1 false, %Ts28__ContiguousArrayStorageBaseC* %0)
  ret %Ts28__ContiguousArrayStorageBaseC* %2
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %49, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %4, %11, %entry
  %15 = phi i64 [ %1, %entry ], [ %13, %11 ], [ %6, %4 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySiGMD") #28
  %21 = shl i64 %17, 3
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 8
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  br i1 %0, label %32, label %42

32:                                               ; preds = %29
  %33 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to %TSi*
  %35 = getelementptr inbounds %TSi, %TSi* %34, i64 %16
  %36 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to %TSi*
  %37 = icmp ugt %TSi* %35, %36
  %38 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond5.i = select i1 %38, i1 %37, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %32
  %39 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to i8*
  %40 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %41 = shl nuw i64 %16, 3
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %40, i8* nonnull align 8 %39, i64 %41, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSi_Tg5.exit": ; preds = %32, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %47

42:                                               ; preds = %29
  %43 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %44 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %45 = bitcast %Ts28__ContiguousArrayStorageBaseC* %44 to i8*
  %46 = shl nuw i64 %16, 3
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %43, i8* nonnull align 8 %45, i64 %46, i1 false)
  br label %47

47:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSi_Tg5.exit", %42
  %48 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %48) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

49:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSS_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %47, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %4, %11, %entry
  %15 = phi i64 [ %1, %entry ], [ %13, %11 ], [ %6, %4 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySSGMD") #28
  %21 = shl i64 %17, 4
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 16
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  %32 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  br i1 %0, label %33, label %42

33:                                               ; preds = %29
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %32 to %TSS*
  %35 = getelementptr inbounds %TSS, %TSS* %34, i64 %16
  %36 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to %TSS*
  %37 = icmp ugt %TSS* %35, %36
  %38 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond5.i = select i1 %38, i1 %37, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSS_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %33
  %39 = bitcast %Ts28__ContiguousArrayStorageBaseC* %32 to i8*
  %40 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %41 = shl nuw i64 %16, 4
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %40, i8* nonnull align 8 %39, i64 %41, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSS_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSS_Tg5.exit": ; preds = %33, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %45

42:                                               ; preds = %29
  %43 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to %swift.opaque*
  %44 = bitcast %Ts28__ContiguousArrayStorageBaseC* %32 to %swift.opaque*
  tail call void @swift_arrayInitWithCopy(%swift.opaque* nonnull %43, %swift.opaque* nonnull %44, i64 %16, %swift.type* nonnull @"$sSSN") #27
  br label %45

45:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSS_Tg5.exit", %42
  %46 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %46) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

47:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi6offset_Si1l_Si1rt7elementt_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %49, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %4, %11, %entry
  %15 = phi i64 [ %1, %entry ], [ %13, %11 ], [ %6, %4 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySi6offset_Si1l_Si1rt7elementtGMD") #28
  %21 = mul i64 %17, 24
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 24
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  br i1 %0, label %32, label %42

32:                                               ; preds = %29
  %33 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %35 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %34, i64 %16
  %36 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %37 = icmp ugt <{ %TSi, <{ %TSi, %TSi }> }>* %35, %36
  %38 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond5.i = select i1 %38, i1 %37, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %32
  %39 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to i8*
  %40 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %41 = mul nuw i64 %16, 24
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %40, i8* nonnull align 8 %39, i64 %41, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit": ; preds = %32, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %47

42:                                               ; preds = %29
  %43 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %44 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %45 = bitcast %Ts28__ContiguousArrayStorageBaseC* %44 to i8*
  %46 = mul nuw i64 %16, 24
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %43, i8* nonnull align 8 %45, i64 %46, i1 false)
  br label %47

47:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit", %42
  %48 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %48) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

49:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSiSg_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %43, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %4, %11, %entry
  %15 = phi i64 [ %1, %entry ], [ %13, %11 ], [ %6, %4 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySiSgGMD") #28
  %21 = shl i64 %17, 4
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 16
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  %32 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %33 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to i8*
  %35 = shl i64 %16, 4
  br i1 %0, label %36, label %40

36:                                               ; preds = %29
  %37 = getelementptr inbounds i8, i8* %34, i64 %35
  %38 = icmp ugt i8* %37, %32
  %39 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond8.i = select i1 %39, i1 %38, i1 false
  br i1 %or.cond8.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSiSg_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %36
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %32, i8* nonnull align 8 %34, i64 %35, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSiSg_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSiSg_Tg5.exit": ; preds = %36, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %41

40:                                               ; preds = %29
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %32, i8* nonnull align 8 %34, i64 %35, i1 false)
  br label %41

41:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSiSg_Tg5.exit", %40
  %42 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %42) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

43:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi1l_Si1rt_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %49, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %4, %11, %entry
  %15 = phi i64 [ %1, %entry ], [ %13, %11 ], [ %6, %4 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySi1l_Si1rtGMD") #28
  %21 = shl i64 %17, 4
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 16
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  br i1 %0, label %32, label %42

32:                                               ; preds = %29
  %33 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to <{ %TSi, %TSi }>*
  %35 = getelementptr inbounds <{ %TSi, %TSi }>, <{ %TSi, %TSi }>* %34, i64 %16
  %36 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to <{ %TSi, %TSi }>*
  %37 = icmp ugt <{ %TSi, %TSi }>* %35, %36
  %38 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond5.i = select i1 %38, i1 %37, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi1l_Si1rt_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %32
  %39 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to i8*
  %40 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %41 = shl nuw i64 %16, 4
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %40, i8* nonnull align 8 %39, i64 %41, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi1l_Si1rt_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSi1l_Si1rt_Tg5.exit": ; preds = %32, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %47

42:                                               ; preds = %29
  %43 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %44 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %45 = bitcast %Ts28__ContiguousArrayStorageBaseC* %44 to i8*
  %46 = shl nuw i64 %16, 4
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %43, i8* nonnull align 8 %45, i64 %46, i1 false)
  br label %47

47:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSi1l_Si1rt_Tg5.exit", %42
  %48 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %48) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

49:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$ss23_ContiguousArrayStorageCfDs7CVarArg_p_Tg5"(%Ts23_ContiguousArrayStorageCys7CVarArg_pG* swiftself %0) local_unnamed_addr #0 {
entry:
  %1 = getelementptr inbounds %Ts23_ContiguousArrayStorageCys7CVarArg_pG, %Ts23_ContiguousArrayStorageCys7CVarArg_pG* %0, i64 1
  %._storage.count._value = getelementptr inbounds %Ts23_ContiguousArrayStorageCys7CVarArg_pG, %Ts23_ContiguousArrayStorageCys7CVarArg_pG* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %2 = load i64, i64* %._storage.count._value, align 8, !range !6
  %3 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss7CVarArg_pMD") #28
  %4 = bitcast %Ts23_ContiguousArrayStorageCys7CVarArg_pG* %1 to %swift.opaque*
  tail call void @swift_arrayDestroy(%swift.opaque* nonnull %4, i64 %2, %swift.type* %3) #9
  %5 = getelementptr %Ts23_ContiguousArrayStorageCys7CVarArg_pG, %Ts23_ContiguousArrayStorageCys7CVarArg_pG* %0, i64 0, i32 0
  tail call void @swift_deallocClassInstance(%swift.refcounted* %5, i64 32, i64 7) #9
  ret void
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$sSr15_stableSortImpl2byySbx_xtKXE_tKFSi6offset_Si1l_Si1rt7elementt_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_l3AC_L13ADtAEttXEfU0_Tf1cn_n"(%TSrySi6offset_Si1l_Si1rt7elementtG* nocapture dereferenceable(16) %0, %swift.refcounted* swiftself %1, %swift.error** noalias nocapture swifterror dereferenceable(8) %2) local_unnamed_addr #0 {
entry:
  %.count._value = getelementptr inbounds %TSrySi6offset_Si1l_Si1rt7elementtG, %TSrySi6offset_Si1l_Si1rt7elementtG* %0, i64 0, i32 1, i32 0
  %3 = load i64, i64* %.count._value, align 8
  %4 = tail call swiftcc i64 @"$ss22_minimumMergeRunLengthyS2iF"(i64 %3)
  %5 = icmp slt i64 %4, %3
  br i1 %5, label %6, label %11

6:                                                ; preds = %entry
  %7 = sdiv i64 %3, 2
  %8 = icmp slt i64 %3, -1
  br i1 %8, label %305, label %9, !prof !7

9:                                                ; preds = %6
  %10 = icmp sgt i64 %3, 1
  br i1 %10, label %.thread241, label %19

11:                                               ; preds = %entry
  %12 = icmp slt i64 %3, 0
  br i1 %12, label %304, label %13, !prof !7

13:                                               ; preds = %11
  %14 = icmp eq i64 %3, 0
  br i1 %14, label %common.ret, label %302

.thread241:                                       ; preds = %9
  %15 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$sSi6offset_Si1l_Si1rt7elementtMD") #28
  %16 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64 %7, %swift.type* %15)
  %._storage63.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %16, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %7, i64* %._storage63.count._value, align 8
  %17 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %16, i64 1
  %18 = bitcast %Ts28__ContiguousArrayStorageBaseC* %17 to i8*
  br label %.preheader148

19:                                               ; preds = %9
  %20 = icmp eq i64 %3, 1
  br i1 %20, label %.preheader148, label %..loopexit149_crit_edge

..loopexit149_crit_edge:                          ; preds = %19
  %.pre231 = load i64, i64* getelementptr inbounds (%struct._SwiftEmptyArrayStorage, %struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage, i64 0, i32 1, i32 0), align 8, !range !6
  br label %.loopexit149

.preheader148:                                    ; preds = %.thread241, %19
  %21 = phi i8* [ %18, %.thread241 ], [ bitcast (%struct.HeapMetadata** getelementptr inbounds (%struct._SwiftEmptyArrayStorage, %struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage, i64 1, i32 0, i32 0) to i8*), %19 ]
  %22 = phi %Ts28__ContiguousArrayStorageBaseC* [ %16, %.thread241 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %19 ]
  %23 = bitcast %TSrySi6offset_Si1l_Si1rt7elementtG* %0 to i64*
  br label %24

24:                                               ; preds = %.preheader148, %.loopexit
  %25 = phi i64 [ %89, %.loopexit ], [ 0, %.preheader148 ]
  %26 = phi i64 [ %72, %.loopexit ], [ %3, %.preheader148 ]
  %27 = phi %Ts28__ContiguousArrayStorageBaseC* [ %108, %.loopexit ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %.preheader148 ]
  %28 = add nsw i64 %25, 1
  %29 = icmp slt i64 %28, %26
  br i1 %29, label %30, label %.loopexit145

30:                                               ; preds = %24
  %31 = load i64, i64* %23, align 8
  %32 = inttoptr i64 %31 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %.element55.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %32, i64 %28, i32 1, i32 1, i32 0
  %33 = load i64, i64* %.element55.r._value, align 8
  %.element56.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %32, i64 %25, i32 1, i32 1, i32 0
  %34 = load i64, i64* %.element56.r._value, align 8
  %35 = icmp slt i64 %34, %33
  %36 = add nsw i64 %25, 2
  %37 = icmp slt i64 %36, %26
  br i1 %37, label %.preheader146, label %.loopexit147

.preheader146:                                    ; preds = %30, %43
  %38 = phi i64 [ %40, %43 ], [ %33, %30 ]
  %39 = phi i64 [ %44, %43 ], [ %36, %30 ]
  %.element61.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %32, i64 %39, i32 1, i32 1, i32 0
  %40 = load i64, i64* %.element61.r._value, align 8
  %41 = icmp sge i64 %38, %40
  %42 = xor i1 %35, %41
  br i1 %42, label %43, label %.loopexit147

43:                                               ; preds = %.preheader146
  %44 = add nsw i64 %39, 1
  %45 = icmp slt i64 %44, %26
  br i1 %45, label %.preheader146, label %.loopexit147

.loopexit147:                                     ; preds = %43, %.preheader146, %30
  %46 = phi i64 [ %36, %30 ], [ %26, %43 ], [ %39, %.preheader146 ]
  br i1 %35, label %47, label %.loopexit145

47:                                               ; preds = %.loopexit147
  %48 = icmp slt i64 %46, %25
  br i1 %48, label %332, label %49, !prof !7

49:                                               ; preds = %47
  %50 = icmp slt i64 %25, %46
  br i1 %50, label %.preheader144, label %.loopexit145

.preheader144:                                    ; preds = %49, %68
  %51 = phi i64 [ %53, %68 ], [ %46, %49 ]
  %52 = phi i64 [ %69, %68 ], [ %25, %49 ]
  %53 = add nsw i64 %51, -1
  %54 = load i64, i64* %23, align 8
  %55 = icmp eq i64 %52, %53
  br i1 %55, label %68, label %56

56:                                               ; preds = %.preheader144
  %57 = icmp eq i64 %54, 0
  br i1 %57, label %333, label %58

58:                                               ; preds = %56
  %59 = inttoptr i64 %54 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %60 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %59, i64 %52
  %61 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %60 to i8*
  %62 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %59, i64 %53
  %63 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %62 to i8*
  %.element58.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %59, i64 %52, i32 1, i32 1, i32 0
  %64 = load i64, i64* %.element58.r._value, align 8
  %65 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %60 to <2 x i64>*
  %66 = load <2 x i64>, <2 x i64>* %65, align 8
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %61, i8* noundef nonnull align 8 dereferenceable(24) %63, i64 24, i1 false)
  %67 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %62 to <2 x i64>*
  store <2 x i64> %66, <2 x i64>* %67, align 8
  %.element60.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %59, i64 %53, i32 1, i32 1, i32 0
  store i64 %64, i64* %.element60.r._value, align 8
  br label %68

68:                                               ; preds = %.preheader144, %58
  %69 = add nsw i64 %52, 1
  %70 = icmp slt i64 %69, %53
  br i1 %70, label %.preheader144, label %.loopexit145

.loopexit145:                                     ; preds = %68, %49, %.loopexit147, %24
  %71 = phi i64 [ %28, %24 ], [ %46, %.loopexit147 ], [ %46, %49 ], [ %46, %68 ]
  %72 = load i64, i64* %.count._value, align 8
  %73 = icmp slt i64 %71, %72
  br i1 %73, label %74, label %.loopexit143

74:                                               ; preds = %.loopexit145
  %75 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %71, i64 %25)
  %76 = extractvalue { i64, i1 } %75, 1
  br i1 %76, label %328, label %77, !prof !7

77:                                               ; preds = %74
  %78 = extractvalue { i64, i1 } %75, 0
  %79 = icmp slt i64 %78, %4
  br i1 %79, label %80, label %.loopexit143

80:                                               ; preds = %77
  %81 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %25, i64 %4)
  %82 = extractvalue { i64, i1 } %81, 1
  br i1 %82, label %329, label %83, !prof !7

83:                                               ; preds = %80
  %84 = extractvalue { i64, i1 } %81, 0
  %85 = tail call i64 @llvm.smin.i64(i64 %84, i64 %72)
  %86 = icmp slt i64 %85, %25
  br i1 %86, label %330, label %87, !prof !7

87:                                               ; preds = %83
  %88 = icmp eq i64 %71, %85
  br i1 %88, label %.loopexit143, label %.preheader

.loopexit143:                                     ; preds = %299, %87, %77, %.loopexit145
  %89 = phi i64 [ %71, %.loopexit145 ], [ %71, %77 ], [ %71, %87 ], [ %85, %299 ]
  %90 = icmp slt i64 %89, %25
  br i1 %90, label %311, label %91, !prof !7

91:                                               ; preds = %.loopexit143
  %92 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %27, i64 0, i32 0
  %93 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %92) #27
  br i1 %93, label %98, label %94

94:                                               ; preds = %91
  %._storage13.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %27, i64 0, i32 1, i32 0, i32 0, i32 0
  %95 = load i64, i64* %._storage13.count._value, align 8, !range !6
  %96 = add nuw nsw i64 %95, 1
  %97 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSnySiG_Tgq5"(i1 false, i64 %96, i1 true, %Ts28__ContiguousArrayStorageBaseC* %27)
  br label %98

98:                                               ; preds = %91, %94
  %99 = phi %Ts28__ContiguousArrayStorageBaseC* [ %97, %94 ], [ %27, %91 ]
  %._storage14.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %99, i64 0, i32 1, i32 0, i32 0, i32 0
  %100 = load i64, i64* %._storage14.count._value, align 8, !range !6
  %._storage14._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %99, i64 0, i32 1, i32 0, i32 1, i32 0
  %101 = load i64, i64* %._storage14._capacityAndFlags._value, align 8
  %102 = lshr i64 %101, 1
  %103 = add nuw nsw i64 %100, 1
  %.not133 = icmp ugt i64 %102, %100
  br i1 %.not133, label %107, label %104, !prof !8

104:                                              ; preds = %98
  %105 = icmp ugt i64 %101, 1
  %106 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSnySiG_Tgq5"(i1 %105, i64 %103, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull %99)
  br label %107

107:                                              ; preds = %98, %104
  %108 = phi %Ts28__ContiguousArrayStorageBaseC* [ %106, %104 ], [ %99, %98 ]
  %._storage15.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %108, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %103, i64* %._storage15.count._value, align 8
  %109 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %108, i64 1
  %tailaddr16 = bitcast %Ts28__ContiguousArrayStorageBaseC* %109 to %TSnySiG*
  %.lowerBound17._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %100, i32 0, i32 0
  store i64 %25, i64* %.lowerBound17._value, align 8
  %.upperBound18._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %100, i32 1, i32 0
  store i64 %89, i64* %.upperBound18._value, align 8
  %.not141 = icmp eq i64 %100, 0
  br i1 %.not141, label %.loopexit, label %thread-pre-split

thread-pre-split:                                 ; preds = %107
  %.lowerBound47._value.phi.trans.insert = bitcast %Ts28__ContiguousArrayStorageBaseC* %109 to i64*
  %110 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %108, i64 1, i32 0, i32 1
  %111 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %108, i64 1, i32 0, i32 1
  %.lowerBound40._value.phi.trans.insert = bitcast %Ts28__ContiguousArrayStorageBaseC* %109 to i64*
  br label %112

112:                                              ; preds = %thread-pre-split, %261
  %113 = phi i64 [ %103, %thread-pre-split ], [ %262, %261 ]
  %114 = add nsw i64 %113, -1
  %115 = icmp ult i64 %113, 4
  br i1 %115, label %143, label %116

116:                                              ; preds = %112
  %117 = add nsw i64 %113, -4
  %.lowerBound22._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %117, i32 0, i32 0
  %118 = load i64, i64* %.lowerBound22._value, align 8
  %.upperBound23._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %117, i32 1, i32 0
  %119 = load i64, i64* %.upperBound23._value, align 8
  %120 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %119, i64 %118)
  %121 = extractvalue { i64, i1 } %120, 0
  %122 = extractvalue { i64, i1 } %120, 1
  br i1 %122, label %312, label %123, !prof !7

123:                                              ; preds = %116
  %124 = add nsw i64 %113, -3
  %.lowerBound24._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %124, i32 0, i32 0
  %125 = load i64, i64* %.lowerBound24._value, align 8
  %.upperBound25._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %124, i32 1, i32 0
  %126 = load i64, i64* %.upperBound25._value, align 8
  %127 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %126, i64 %125)
  %128 = extractvalue { i64, i1 } %127, 0
  %129 = extractvalue { i64, i1 } %127, 1
  br i1 %129, label %313, label %130, !prof !7

130:                                              ; preds = %123
  %131 = add nsw i64 %113, -2
  %.lowerBound26._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %131, i32 0, i32 0
  %132 = load i64, i64* %.lowerBound26._value, align 8
  %.upperBound27._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %131, i32 1, i32 0
  %133 = load i64, i64* %.upperBound27._value, align 8
  %134 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %133, i64 %132)
  %135 = extractvalue { i64, i1 } %134, 1
  br i1 %135, label %314, label %136, !prof !7

136:                                              ; preds = %130
  %137 = extractvalue { i64, i1 } %134, 0
  %138 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %128, i64 %137)
  %139 = extractvalue { i64, i1 } %138, 1
  br i1 %139, label %315, label %140, !prof !7

140:                                              ; preds = %136
  %141 = extractvalue { i64, i1 } %138, 0
  %142 = icmp slt i64 %141, %121
  br i1 %142, label %.thread, label %271

143:                                              ; preds = %112
  %.not142 = icmp eq i64 %113, 3
  br i1 %.not142, label %..thread_crit_edge, label %._crit_edge

..thread_crit_edge:                               ; preds = %143
  %.pre228 = load i64, i64* %111, align 8
  %.pre = load i64, i64* %.lowerBound40._value.phi.trans.insert, align 8
  %.pre232 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %.pre228, i64 %.pre)
  %.pre234 = extractvalue { i64, i1 } %.pre232, 0
  br label %.thread

.thread:                                          ; preds = %..thread_crit_edge, %140
  %.pre-phi235 = phi i64 [ %.pre234, %..thread_crit_edge ], [ %128, %140 ]
  %.pre-phi233 = phi { i64, i1 } [ %.pre232, %..thread_crit_edge ], [ %127, %140 ]
  %144 = extractvalue { i64, i1 } %.pre-phi233, 1
  br i1 %144, label %322, label %145, !prof !7

145:                                              ; preds = %.thread
  %146 = add nsw i64 %113, -2
  %.lowerBound42._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %146, i32 0, i32 0
  %147 = load i64, i64* %.lowerBound42._value, align 8
  %.upperBound43._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %146, i32 1, i32 0
  %148 = load i64, i64* %.upperBound43._value, align 8
  %149 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %148, i64 %147)
  %150 = extractvalue { i64, i1 } %149, 0
  %151 = extractvalue { i64, i1 } %149, 1
  br i1 %151, label %323, label %152, !prof !7

152:                                              ; preds = %145
  %.lowerBound44._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 0, i32 0
  %153 = load i64, i64* %.lowerBound44._value, align 8
  %.upperBound45._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 1, i32 0
  %154 = load i64, i64* %.upperBound45._value, align 8
  %155 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %154, i64 %153)
  %156 = extractvalue { i64, i1 } %155, 0
  %157 = extractvalue { i64, i1 } %155, 1
  br i1 %157, label %324, label %158, !prof !7

158:                                              ; preds = %152
  %159 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %150, i64 %156)
  %160 = extractvalue { i64, i1 } %159, 1
  br i1 %160, label %325, label %161, !prof !7

161:                                              ; preds = %158
  %162 = extractvalue { i64, i1 } %159, 0
  %163 = icmp slt i64 %162, %.pre-phi235
  br i1 %163, label %.thread140, label %269

._crit_edge:                                      ; preds = %143
  %.pre229 = load i64, i64* %.lowerBound47._value.phi.trans.insert, align 8
  %.pre230 = load i64, i64* %110, align 8
  %.pre236 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %.pre230, i64 %.pre229)
  %.pre238 = extractvalue { i64, i1 } %.pre236, 0
  br label %.thread140

.thread140:                                       ; preds = %161, %._crit_edge
  %.pre-phi239 = phi i64 [ %.pre238, %._crit_edge ], [ %150, %161 ]
  %.pre-phi237 = phi { i64, i1 } [ %.pre236, %._crit_edge ], [ %149, %161 ]
  %164 = extractvalue { i64, i1 } %.pre-phi237, 1
  br i1 %164, label %326, label %165, !prof !7

165:                                              ; preds = %.thread140
  %.lowerBound49._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 0, i32 0
  %166 = load i64, i64* %.lowerBound49._value, align 8
  %.upperBound50._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 1, i32 0
  %167 = load i64, i64* %.upperBound50._value, align 8
  %168 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %167, i64 %166)
  %169 = extractvalue { i64, i1 } %168, 1
  br i1 %169, label %327, label %170, !prof !7

170:                                              ; preds = %165
  %171 = extractvalue { i64, i1 } %168, 0
  %172 = icmp slt i64 %171, %.pre-phi239
  br i1 %172, label %.loopexit, label %235

.loopexit:                                        ; preds = %261, %170, %107
  %173 = phi i64 [ 1, %107 ], [ %262, %261 ], [ %113, %170 ]
  %174 = icmp slt i64 %89, %72
  br i1 %174, label %24, label %.loopexit149

.loopexit149:                                     ; preds = %.loopexit, %..loopexit149_crit_edge
  %175 = phi i8* [ bitcast (%struct.HeapMetadata** getelementptr inbounds (%struct._SwiftEmptyArrayStorage, %struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage, i64 1, i32 0, i32 0) to i8*), %..loopexit149_crit_edge ], [ %21, %.loopexit ]
  %176 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %..loopexit149_crit_edge ], [ %22, %.loopexit ]
  %177 = phi i64 [ %.pre231, %..loopexit149_crit_edge ], [ %173, %.loopexit ]
  %178 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %..loopexit149_crit_edge ], [ %108, %.loopexit ]
  %179 = icmp ugt i64 %177, 1
  br i1 %179, label %180, label %.loopexit283

180:                                              ; preds = %.loopexit149
  %181 = bitcast %TSrySi6offset_Si1l_Si1rt7elementtG* %0 to i64*
  %182 = load i64, i64* %181, align 8
  %183 = icmp eq i64 %182, 0
  %184 = inttoptr i64 %182 to <{ %TSi, <{ %TSi, %TSi }> }>*
  br label %185

185:                                              ; preds = %218, %180
  %186 = phi i64 [ %177, %180 ], [ %219, %218 ]
  %187 = phi %Ts28__ContiguousArrayStorageBaseC* [ %178, %180 ], [ %213, %218 ]
  %188 = add nsw i64 %186, -1
  %189 = add nsw i64 %186, -2
  %190 = icmp ult i64 %186, 2
  br i1 %190, label %306, label %191, !prof !7

191:                                              ; preds = %185
  %192 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %187, i64 1
  %tailaddr3 = bitcast %Ts28__ContiguousArrayStorageBaseC* %192 to %TSnySiG*
  %.lowerBound._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr3, i64 %189, i32 0, i32 0
  %193 = load i64, i64* %.lowerBound._value, align 8
  %.upperBound._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr3, i64 %188, i32 1, i32 0
  %194 = load i64, i64* %.upperBound._value, align 8
  br i1 %183, label %307, label %195

195:                                              ; preds = %191
  %.lowerBound4._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr3, i64 %188, i32 0, i32 0
  %196 = load i64, i64* %.lowerBound4._value, align 8
  %197 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %184, i64 %193
  %198 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %197 to i8*
  %199 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %184, i64 %196
  %200 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %199 to i8*
  %201 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %184, i64 %194
  %202 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %201 to i8*
  %203 = tail call swiftcc i1 @"$ss6_merge3low3mid4high6buffer2bySbSpyxG_A3GSbx_xtKXEtKlFSi6offset_Si1l_Si1rt7elementt_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_n3AC_N13ADtAEttXEfU0_Tf1nnnnc_n"(i8* nonnull %198, i8* nonnull %200, i8* nonnull %202, i8* nonnull %175, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture nonnull swifterror dereferenceable(8) %2)
  %204 = load %swift.error*, %swift.error** %2, align 8
  %.not130 = icmp eq %swift.error* %204, null
  br i1 %.not130, label %205, label %.loopexit282

205:                                              ; preds = %195
  %206 = icmp slt i64 %194, %193
  br i1 %206, label %308, label %207, !prof !7

207:                                              ; preds = %205
  %208 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %187, i64 0, i32 0
  %209 = tail call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %208) #27
  br i1 %209, label %212, label %210

210:                                              ; preds = %207
  %211 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSnySiG_Tgq5"(%Ts28__ContiguousArrayStorageBaseC* nonnull %187)
  br label %212

212:                                              ; preds = %207, %210
  %213 = phi %Ts28__ContiguousArrayStorageBaseC* [ %211, %210 ], [ %187, %207 ]
  %._storage6.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %213, i64 0, i32 1, i32 0, i32 0, i32 0
  %214 = load i64, i64* %._storage6.count._value, align 8, !range !6
  %.not131 = icmp ult i64 %189, %214
  br i1 %.not131, label %215, label %309, !prof !8

215:                                              ; preds = %212
  %216 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %213, i64 1
  %tailaddr7 = bitcast %Ts28__ContiguousArrayStorageBaseC* %216 to %TSnySiG*
  %.lowerBound8._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr7, i64 %189, i32 0, i32 0
  store i64 %193, i64* %.lowerBound8._value, align 8
  %.upperBound9._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr7, i64 %189, i32 1, i32 0
  store i64 %194, i64* %.upperBound9._value, align 8
  %217 = load i64, i64* %._storage6.count._value, align 8, !range !6
  %.not132 = icmp ugt i64 %186, %217
  br i1 %.not132, label %310, label %218, !prof !7

218:                                              ; preds = %215
  %219 = add nsw i64 %217, -1
  %220 = sub nsw i64 %219, %188
  %221 = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr7, i64 %186
  %222 = bitcast %TSnySiG* %221 to i8*
  %223 = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr7, i64 %188
  %224 = bitcast %TSnySiG* %223 to i8*
  %225 = shl nuw i64 %220, 4
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %224, i8* nonnull align 8 %222, i64 %225, i1 false)
  store i64 %219, i64* %._storage6.count._value, align 8
  %226 = icmp ugt i64 %217, 2
  br i1 %226, label %185, label %.loopexit283

.loopexit283:                                     ; preds = %218, %.loopexit149
  %.lcssa256.sink = phi %Ts28__ContiguousArrayStorageBaseC* [ %178, %.loopexit149 ], [ %213, %218 ]
  %227 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.lcssa256.sink, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %227) #9
  %._storage1.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %176, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 0, i64* %._storage1.count._value, align 8
  %228 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %176, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %228) #9
  br label %common.ret

common.ret:                                       ; preds = %302, %13, %.loopexit283, %233
  ret void

.loopexit282:                                     ; preds = %244, %195
  %.lcssa275.sink = phi %Ts28__ContiguousArrayStorageBaseC* [ %187, %195 ], [ %108, %244 ]
  %229 = phi %Ts28__ContiguousArrayStorageBaseC* [ %176, %195 ], [ %22, %244 ]
  %230 = phi %swift.error* [ %204, %195 ], [ %254, %244 ]
  %231 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.lcssa275.sink, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %231) #9
  %._storage5.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %229, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 0, i64* %._storage5.count._value, align 8
  %232 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %229, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %232) #9
  br label %233

233:                                              ; preds = %302, %.loopexit282
  %234 = phi %swift.error* [ %230, %.loopexit282 ], [ %303, %302 ]
  store %swift.error* %234, %swift.error** %2, align 8
  br label %common.ret

235:                                              ; preds = %276, %269, %170
  %236 = phi i64 [ %114, %170 ], [ %.64, %269 ], [ %.65, %276 ]
  %237 = add nsw i64 %236, -1
  %.not134 = icmp ult i64 %237, %113
  br i1 %.not134, label %238, label %317, !prof !8

238:                                              ; preds = %235
  %.lowerBound31._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %237, i32 0, i32 0
  %239 = load i64, i64* %.lowerBound31._value, align 8
  %240 = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %236
  %.upperBound33._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %236, i32 1, i32 0
  %241 = load i64, i64* %.upperBound33._value, align 8
  %242 = load i64, i64* %23, align 8
  %243 = icmp eq i64 %242, 0
  br i1 %243, label %318, label %244

244:                                              ; preds = %238
  %.lowerBound32._value = getelementptr inbounds %TSnySiG, %TSnySiG* %240, i64 0, i32 0, i32 0
  %245 = load i64, i64* %.lowerBound32._value, align 8
  %246 = inttoptr i64 %242 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %247 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %246, i64 %239
  %248 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %247 to i8*
  %249 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %246, i64 %245
  %250 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %249 to i8*
  %251 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %246, i64 %241
  %252 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %251 to i8*
  %253 = tail call swiftcc i1 @"$ss6_merge3low3mid4high6buffer2bySbSpyxG_A3GSbx_xtKXEtKlFSi6offset_Si1l_Si1rt7elementt_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_n3AC_N13ADtAEttXEfU0_Tf1nnnnc_n"(i8* nonnull %248, i8* nonnull %250, i8* nonnull %252, i8* nonnull %21, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture nonnull swifterror dereferenceable(8) %2)
  %254 = load %swift.error*, %swift.error** %2, align 8
  %.not136 = icmp eq %swift.error* %254, null
  br i1 %.not136, label %255, label %.loopexit282

255:                                              ; preds = %244
  %256 = icmp slt i64 %241, %239
  br i1 %256, label %319, label %257, !prof !7

257:                                              ; preds = %255
  %258 = load i64, i64* %._storage15.count._value, align 8, !range !6
  %.not137 = icmp ult i64 %237, %258
  br i1 %.not137, label %259, label %320, !prof !8

259:                                              ; preds = %257
  store i64 %239, i64* %.lowerBound31._value, align 8
  %.upperBound37._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %237, i32 1, i32 0
  store i64 %241, i64* %.upperBound37._value, align 8
  %260 = load i64, i64* %._storage15.count._value, align 8, !range !6
  %.not138 = icmp ult i64 %236, %260
  br i1 %.not138, label %261, label %321, !prof !8

261:                                              ; preds = %259
  %262 = add nsw i64 %260, -1
  %263 = sub nsw i64 %262, %236
  %264 = getelementptr inbounds %TSnySiG, %TSnySiG* %240, i64 1
  %265 = bitcast %TSnySiG* %264 to i8*
  %266 = bitcast %TSnySiG* %240 to i8*
  %267 = shl nuw i64 %263, 4
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %266, i8* nonnull align 8 %265, i64 %267, i1 false)
  store i64 %262, i64* %._storage15.count._value, align 8
  %268 = icmp ugt i64 %260, 2
  br i1 %268, label %112, label %.loopexit

269:                                              ; preds = %161
  %270 = icmp slt i64 %.pre-phi235, %156
  %.64 = select i1 %270, i64 %146, i64 %114
  br label %235

271:                                              ; preds = %140
  %.lowerBound28._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 0, i32 0
  %272 = load i64, i64* %.lowerBound28._value, align 8
  %.upperBound29._value = getelementptr inbounds %TSnySiG, %TSnySiG* %tailaddr16, i64 %114, i32 1, i32 0
  %273 = load i64, i64* %.upperBound29._value, align 8
  %274 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %273, i64 %272)
  %275 = extractvalue { i64, i1 } %274, 1
  br i1 %275, label %316, label %276, !prof !7

276:                                              ; preds = %271
  %277 = extractvalue { i64, i1 } %274, 0
  %278 = icmp slt i64 %128, %277
  %.65 = select i1 %278, i64 %131, i64 %114
  br label %235

.preheader:                                       ; preds = %87, %299
  %279 = phi i64 [ %300, %299 ], [ %71, %87 ]
  br label %280

280:                                              ; preds = %292, %.preheader
  %281 = phi i64 [ %279, %.preheader ], [ %282, %292 ]
  %282 = add i64 %281, -1
  %283 = load i64, i64* %23, align 8
  %284 = inttoptr i64 %283 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %285 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %284, i64 %281
  %.element.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %284, i64 %281, i32 1, i32 1, i32 0
  %286 = load i64, i64* %.element.r._value, align 8
  %287 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %284, i64 %282
  %.element51.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %284, i64 %282, i32 1, i32 1, i32 0
  %288 = load i64, i64* %.element51.r._value, align 8
  %289 = icmp slt i64 %288, %286
  br i1 %289, label %290, label %299

290:                                              ; preds = %280
  %291 = icmp eq i64 %283, 0
  br i1 %291, label %331, label %292

292:                                              ; preds = %290
  %293 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %287 to i8*
  %294 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %285 to i8*
  %295 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %285 to <2 x i64>*
  %296 = load <2 x i64>, <2 x i64>* %295, align 8
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %294, i8* noundef nonnull align 8 dereferenceable(24) %293, i64 24, i1 false)
  %297 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %287 to <2 x i64>*
  store <2 x i64> %296, <2 x i64>* %297, align 8
  store i64 %286, i64* %.element51.r._value, align 8
  %298 = icmp eq i64 %282, %25
  br i1 %298, label %299, label %280

299:                                              ; preds = %292, %280
  %300 = add i64 %279, 1
  %301 = icmp eq i64 %300, %85
  br i1 %301, label %.loopexit143, label %.preheader

302:                                              ; preds = %13
  tail call swiftcc void @"$sSMsSKRzrlE14_insertionSort6within9sortedEnd2byySny5IndexSlQzG_AFSb7ElementSTQz_AItKXEtKFSrySi6offset_Si1l_Si1rt7elementtG_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_p3AC_P13ADtAEttXEfU0_Tf1nncn_n"(i64 0, i64 %3, i64 1, %TSrySi6offset_Si1l_Si1rt7elementtG* nocapture nonnull dereferenceable(16) %0, %swift.refcounted* swiftself undef, %swift.error** noalias nocapture nonnull swifterror dereferenceable(8) %2)
  %303 = load %swift.error*, %swift.error** %2, align 8
  %.not = icmp eq %swift.error* %303, null
  br i1 %.not, label %common.ret, label %233

304:                                              ; preds = %11
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable

305:                                              ; preds = %6
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

306:                                              ; preds = %185
  tail call void asm sideeffect "", "n"(i32 4) #9
  tail call void @llvm.trap()
  unreachable

307:                                              ; preds = %191
  tail call void asm sideeffect "", "n"(i32 6) #9
  tail call void @llvm.trap()
  unreachable

308:                                              ; preds = %205
  tail call void asm sideeffect "", "n"(i32 7) #9
  tail call void @llvm.trap()
  unreachable

309:                                              ; preds = %212
  tail call void asm sideeffect "", "n"(i32 8) #9
  tail call void @llvm.trap()
  unreachable

310:                                              ; preds = %215
  tail call void asm sideeffect "", "n"(i32 9) #9
  tail call void @llvm.trap()
  unreachable

311:                                              ; preds = %.loopexit143
  tail call void asm sideeffect "", "n"(i32 12) #9
  tail call void @llvm.trap()
  unreachable

312:                                              ; preds = %116
  tail call void asm sideeffect "", "n"(i32 15) #9
  tail call void @llvm.trap()
  unreachable

313:                                              ; preds = %123
  tail call void asm sideeffect "", "n"(i32 17) #9
  tail call void @llvm.trap()
  unreachable

314:                                              ; preds = %130
  tail call void asm sideeffect "", "n"(i32 19) #9
  tail call void @llvm.trap()
  unreachable

315:                                              ; preds = %136
  tail call void asm sideeffect "", "n"(i32 20) #9
  tail call void @llvm.trap()
  unreachable

316:                                              ; preds = %271
  tail call void asm sideeffect "", "n"(i32 23) #9
  tail call void @llvm.trap()
  unreachable

317:                                              ; preds = %235
  tail call void asm sideeffect "", "n"(i32 25) #9
  tail call void @llvm.trap()
  unreachable

318:                                              ; preds = %238
  tail call void asm sideeffect "", "n"(i32 27) #9
  tail call void @llvm.trap()
  unreachable

319:                                              ; preds = %255
  tail call void asm sideeffect "", "n"(i32 28) #9
  tail call void @llvm.trap()
  unreachable

320:                                              ; preds = %257
  tail call void asm sideeffect "", "n"(i32 29) #9
  tail call void @llvm.trap()
  unreachable

321:                                              ; preds = %259
  tail call void asm sideeffect "", "n"(i32 30) #9
  tail call void @llvm.trap()
  unreachable

322:                                              ; preds = %.thread
  tail call void asm sideeffect "", "n"(i32 34) #9
  tail call void @llvm.trap()
  unreachable

323:                                              ; preds = %145
  tail call void asm sideeffect "", "n"(i32 36) #9
  tail call void @llvm.trap()
  unreachable

324:                                              ; preds = %152
  tail call void asm sideeffect "", "n"(i32 38) #9
  tail call void @llvm.trap()
  unreachable

325:                                              ; preds = %158
  tail call void asm sideeffect "", "n"(i32 39) #9
  tail call void @llvm.trap()
  unreachable

326:                                              ; preds = %.thread140
  tail call void asm sideeffect "", "n"(i32 44) #9
  tail call void @llvm.trap()
  unreachable

327:                                              ; preds = %165
  tail call void asm sideeffect "", "n"(i32 46) #9
  tail call void @llvm.trap()
  unreachable

328:                                              ; preds = %74
  tail call void asm sideeffect "", "n"(i32 47) #9
  tail call void @llvm.trap()
  unreachable

329:                                              ; preds = %80
  tail call void asm sideeffect "", "n"(i32 48) #9
  tail call void @llvm.trap()
  unreachable

330:                                              ; preds = %83
  tail call void asm sideeffect "", "n"(i32 49) #9
  tail call void @llvm.trap()
  unreachable

331:                                              ; preds = %290
  tail call void asm sideeffect "", "n"(i32 50) #9
  tail call void @llvm.trap()
  unreachable

332:                                              ; preds = %47
  tail call void asm sideeffect "", "n"(i32 51) #9
  tail call void @llvm.trap()
  unreachable

333:                                              ; preds = %56
  tail call void asm sideeffect "", "n"(i32 52) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
declare swiftcc i64 @"$ss22_minimumMergeRunLengthyS2iF"(i64) local_unnamed_addr #0

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc void @"$sSMsSKRzrlE14_insertionSort6within9sortedEnd2byySny5IndexSlQzG_AFSb7ElementSTQz_AItKXEtKFSrySi6offset_Si1l_Si1rt7elementtG_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_p3AC_P13ADtAEttXEfU0_Tf1nncn_n"(i64 %0, i64 %1, i64 %2, %TSrySi6offset_Si1l_Si1rt7elementtG* nocapture dereferenceable(16) %3, %swift.refcounted* swiftself %4, %swift.error** noalias nocapture swifterror dereferenceable(8) %5) local_unnamed_addr #0 {
entry:
  %6 = icmp eq i64 %2, %1
  br i1 %6, label %.loopexit, label %.preheader

.preheader:                                       ; preds = %entry
  %7 = bitcast %TSrySi6offset_Si1l_Si1rt7elementtG* %3 to i64*
  br label %8

.loopexit:                                        ; preds = %29, %entry
  ret void

8:                                                ; preds = %.preheader, %29
  %9 = phi i64 [ %30, %29 ], [ %2, %.preheader ]
  br label %10

10:                                               ; preds = %22, %8
  %11 = phi i64 [ %9, %8 ], [ %12, %22 ]
  %12 = add i64 %11, -1
  %13 = load i64, i64* %7, align 8
  %14 = inttoptr i64 %13 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %15 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %14, i64 %11
  %.element.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %14, i64 %11, i32 1, i32 1, i32 0
  %16 = load i64, i64* %.element.r._value, align 8
  %17 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %14, i64 %12
  %.element1.r._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %14, i64 %12, i32 1, i32 1, i32 0
  %18 = load i64, i64* %.element1.r._value, align 8
  %19 = icmp slt i64 %18, %16
  br i1 %19, label %20, label %29

20:                                               ; preds = %10
  %21 = icmp eq i64 %13, 0
  br i1 %21, label %32, label %22

22:                                               ; preds = %20
  %23 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %17 to i8*
  %24 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %15 to i8*
  %25 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %15 to <2 x i64>*
  %26 = load <2 x i64>, <2 x i64>* %25, align 8
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %24, i8* noundef nonnull align 8 dereferenceable(24) %23, i64 24, i1 false)
  %27 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %17 to <2 x i64>*
  store <2 x i64> %26, <2 x i64>* %27, align 8
  store i64 %16, i64* %.element1.r._value, align 8
  %28 = icmp eq i64 %12, %0
  br i1 %28, label %29, label %10

29:                                               ; preds = %22, %10
  %30 = add i64 %9, 1
  %31 = icmp eq i64 %30, %1
  br i1 %31, label %.loopexit, label %8

32:                                               ; preds = %20
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc i1 @"$ss6_merge3low3mid4high6buffer2bySbSpyxG_A3GSbx_xtKXEtKlFSi6offset_Si1l_Si1rt7elementt_Tg5047$s7llvm_OZSbSi6offset_Si1l_Si1rt7elementt_SiAB_n3AC_N13ADtAEttXEfU0_Tf1nnnnc_n"(i8* %0, i8* %1, i8* %2, i8* %3, %swift.refcounted* swiftself %4, %swift.error** noalias nocapture swifterror dereferenceable(8) %5) local_unnamed_addr #0 {
entry:
  %6 = ptrtoint i8* %1 to i64
  %7 = ptrtoint i8* %0 to i64
  %8 = sub i64 %6, %7
  %9 = sdiv i64 %8, 24
  %10 = ptrtoint i8* %2 to i64
  %11 = sub i64 %10, %6
  %12 = sdiv i64 %11, 24
  %13 = icmp slt i64 %9, %12
  br i1 %13, label %14, label %26

14:                                               ; preds = %entry
  %15 = bitcast i8* %0 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %16 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %15, i64 %9
  %17 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %16 to i8*
  %18 = icmp ugt i8* %17, %3
  %19 = icmp eq i8* %3, %0
  %or.cond5.i = select i1 %19, i1 %18, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %14
  %20 = mul nuw nsw i64 %9, 24
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* align 8 %3, i8* align 8 %0, i64 %20, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit": ; preds = %14, %.sink.split.i
  %21 = bitcast i8* %3 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %22 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %21, i64 %9
  %23 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %22 to i8*
  %24 = icmp ugt i8* %23, %3
  %25 = icmp ult i8* %1, %2
  %or.cond = select i1 %24, i1 %25, i1 false
  br i1 %or.cond, label %.preheader, label %.loopexit

26:                                               ; preds = %entry
  %27 = bitcast i8* %1 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %28 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %27, i64 %12
  %29 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %28 to i8*
  %30 = icmp ugt i8* %29, %3
  %31 = icmp eq i8* %3, %1
  %or.cond5.i34 = select i1 %31, i1 %30, i1 false
  br i1 %or.cond5.i34, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36", label %.sink.split.i35

.sink.split.i35:                                  ; preds = %26
  %32 = mul nuw nsw i64 %12, 24
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* align 8 %3, i8* align 8 %1, i64 %32, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36"

"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36": ; preds = %26, %.sink.split.i35
  %33 = bitcast i8* %3 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %34 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %33, i64 %12
  %35 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %34 to i8*
  %36 = icmp ugt i8* %35, %3
  %37 = icmp ult i8* %0, %1
  %or.cond11 = select i1 %36, i1 %37, i1 false
  br i1 %or.cond11, label %.preheader40, label %.loopexit

.preheader:                                       ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit", %52
  %38 = phi i8* [ %53, %52 ], [ %3, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ]
  %39 = phi i8* [ %55, %52 ], [ %0, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ]
  %40 = phi i8* [ %54, %52 ], [ %1, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ]
  %.element2.r = getelementptr inbounds i8, i8* %40, i64 16
  %.element2.r._value = bitcast i8* %.element2.r to i64*
  %41 = load i64, i64* %.element2.r._value, align 8
  %.element3.r = getelementptr inbounds i8, i8* %38, i64 16
  %.element3.r._value = bitcast i8* %.element3.r to i64*
  %42 = load i64, i64* %.element3.r._value, align 8
  %43 = icmp slt i64 %42, %41
  br i1 %43, label %44, label %48

44:                                               ; preds = %.preheader
  %45 = getelementptr inbounds i8, i8* %40, i64 24
  %46 = icmp ult i8* %39, %45
  %47 = icmp eq i8* %39, %40
  %or.cond58 = select i1 %47, i1 %46, i1 false
  br i1 %or.cond58, label %52, label %.sink.split

48:                                               ; preds = %.preheader
  %49 = getelementptr inbounds i8, i8* %38, i64 24
  %50 = icmp ult i8* %39, %49
  %51 = icmp eq i8* %39, %38
  %or.cond59 = select i1 %51, i1 %50, i1 false
  br i1 %or.cond59, label %52, label %.sink.split

.sink.split:                                      ; preds = %44, %48
  %.sink = phi i8* [ %38, %48 ], [ %40, %44 ]
  %.ph = phi i8* [ %49, %48 ], [ %38, %44 ]
  %.ph53 = phi i8* [ %40, %48 ], [ %45, %44 ]
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %39, i8* noundef nonnull align 8 dereferenceable(24) %.sink, i64 24, i1 false)
  br label %52

52:                                               ; preds = %48, %44, %.sink.split
  %53 = phi i8* [ %.ph, %.sink.split ], [ %38, %44 ], [ %49, %48 ]
  %54 = phi i8* [ %.ph53, %.sink.split ], [ %45, %44 ], [ %40, %48 ]
  %55 = getelementptr inbounds i8, i8* %39, i64 24
  %56 = icmp ult i8* %53, %23
  %57 = icmp ult i8* %54, %2
  %or.cond7 = select i1 %56, i1 %57, i1 false
  br i1 %or.cond7, label %.preheader, label %.loopexit.loopexit

.loopexit.loopexit:                               ; preds = %52
  %.pre = bitcast i8* %53 to <{ %TSi, <{ %TSi, %TSi }> }>*
  br label %.loopexit

.loopexit:                                        ; preds = %85, %.loopexit.loopexit, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36", %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit"
  %.pre-phi = phi <{ %TSi, <{ %TSi, %TSi }> }>* [ %.pre, %.loopexit.loopexit ], [ %33, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ], [ %21, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ], [ %33, %85 ]
  %58 = phi i8* [ %23, %.loopexit.loopexit ], [ %35, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ], [ %23, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ], [ %86, %85 ]
  %59 = phi i8* [ %53, %.loopexit.loopexit ], [ %3, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ], [ %3, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ], [ %3, %85 ]
  %60 = phi i8* [ %55, %.loopexit.loopexit ], [ %1, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ], [ %0, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit" ], [ %87, %85 ]
  %61 = ptrtoint i8* %58 to i64
  %62 = ptrtoint i8* %59 to i64
  %63 = sub i64 %61, %62
  %64 = sdiv i64 %63, 24
  %65 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %.pre-phi, i64 %64
  %66 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %65 to i8*
  %67 = icmp ult i8* %60, %66
  %68 = icmp eq i8* %60, %59
  %or.cond5.i37 = select i1 %68, i1 %67, i1 false
  br i1 %or.cond5.i37, label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit39", label %.sink.split.i38

.sink.split.i38:                                  ; preds = %.loopexit
  %69 = mul nuw nsw i64 %64, 24
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* align 8 %60, i8* align 8 %59, i64 %69, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit39"

"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit39": ; preds = %.loopexit, %.sink.split.i38
  ret i1 true

.preheader40:                                     ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36", %85
  %70 = phi i8* [ %73, %85 ], [ %2, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ]
  %71 = phi i8* [ %86, %85 ], [ %35, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ]
  %72 = phi i8* [ %87, %85 ], [ %1, %"$sSp14moveInitialize4from5countySpyxG_SitFSi6offset_Si1l_Si1rt7elementt_Tg5.exit36" ]
  %73 = getelementptr inbounds i8, i8* %70, i64 -24
  %.element.r = getelementptr inbounds i8, i8* %71, i64 -8
  %.element.r._value = bitcast i8* %.element.r to i64*
  %74 = load i64, i64* %.element.r._value, align 8
  %.element1.r = getelementptr inbounds i8, i8* %72, i64 -8
  %.element1.r._value = bitcast i8* %.element1.r to i64*
  %75 = load i64, i64* %.element1.r._value, align 8
  %76 = icmp slt i64 %75, %74
  br i1 %76, label %77, label %81

77:                                               ; preds = %.preheader40
  %78 = getelementptr inbounds i8, i8* %72, i64 -24
  %79 = icmp ult i8* %73, %72
  %80 = icmp eq i8* %70, %72
  %or.cond60 = select i1 %80, i1 %79, i1 false
  br i1 %or.cond60, label %85, label %.sink.split54

81:                                               ; preds = %.preheader40
  %82 = getelementptr inbounds i8, i8* %71, i64 -24
  %83 = icmp ult i8* %73, %71
  %84 = icmp eq i8* %70, %71
  %or.cond61 = select i1 %84, i1 %83, i1 false
  br i1 %or.cond61, label %85, label %.sink.split54

.sink.split54:                                    ; preds = %77, %81
  %.sink57 = phi i8* [ %82, %81 ], [ %78, %77 ]
  %.ph55 = phi i8* [ %82, %81 ], [ %71, %77 ]
  %.ph56 = phi i8* [ %72, %81 ], [ %78, %77 ]
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %73, i8* noundef nonnull align 8 dereferenceable(24) %.sink57, i64 24, i1 false)
  br label %85

85:                                               ; preds = %81, %77, %.sink.split54
  %86 = phi i8* [ %.ph55, %.sink.split54 ], [ %71, %77 ], [ %82, %81 ]
  %87 = phi i8* [ %.ph56, %.sink.split54 ], [ %78, %77 ], [ %72, %81 ]
  %88 = icmp ugt i8* %86, %3
  %89 = icmp ugt i8* %87, %0
  %or.cond15 = select i1 %88, i1 %89, i1 false
  br i1 %or.cond15, label %.preheader40, label %.loopexit
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSnySiG_Tgq5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #5 {
entry:
  br i1 %2, label %4, label %14

4:                                                ; preds = %entry
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 1, i32 0
  %5 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %6 = lshr i64 %5, 1
  %7 = icmp slt i64 %6, %1
  br i1 %7, label %8, label %14

8:                                                ; preds = %4
  %9 = add nuw i64 %6, 4611686018427387904
  %10 = icmp slt i64 %9, 0
  br i1 %10, label %49, label %11, !prof !7

11:                                               ; preds = %8
  %12 = and i64 %5, -2
  %13 = tail call i64 @llvm.smax.i64(i64 %12, i64 %1)
  br label %14

14:                                               ; preds = %11, %4, %entry
  %15 = phi i64 [ %1, %entry ], [ %6, %4 ], [ %13, %11 ]
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 1, i32 0, i32 0, i32 0
  %16 = load i64, i64* %._storage.count._value, align 8, !range !6
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %29, label %19

19:                                               ; preds = %14
  %20 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySnySiGGMD") #28
  %21 = shl i64 %17, 4
  %22 = add i64 %21, 32
  %23 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %20, i64 %22, i64 7) #9
  %24 = bitcast %swift.refcounted* %23 to %Ts28__ContiguousArrayStorageBaseC*
  %25 = bitcast %swift.refcounted* %23 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %25) #30
  %gepdiff = add nsw i64 %call.i, -32
  %26 = sdiv i64 %gepdiff, 16
  %27 = shl nsw i64 %26, 1
  %28 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1
  %._storage7.count._value = bitcast %swift.refcounted* %28 to i64*
  store i64 %16, i64* %._storage7.count._value, align 8
  %._storage7._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %23, i64 1, i32 1
  store i64 %27, i64* %._storage7._capacityAndFlags, align 8
  br label %29

29:                                               ; preds = %14, %19
  %30 = phi %Ts28__ContiguousArrayStorageBaseC* [ %24, %19 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %14 ]
  %31 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %30, i64 1
  br i1 %0, label %37, label %32

32:                                               ; preds = %29
  %33 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %34 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %35 = bitcast %Ts28__ContiguousArrayStorageBaseC* %34 to i8*
  %36 = shl nuw i64 %16, 4
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %33, i8* nonnull align 8 %35, i64 %36, i1 false)
  br label %47

37:                                               ; preds = %29
  %38 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %39 = bitcast %Ts28__ContiguousArrayStorageBaseC* %38 to %TSnySiG*
  %40 = getelementptr inbounds %TSnySiG, %TSnySiG* %39, i64 %16
  %41 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to %TSnySiG*
  %42 = icmp ugt %TSnySiG* %40, %41
  %43 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond5.i = select i1 %43, i1 %42, i1 false
  br i1 %or.cond5.i, label %"$sSp14moveInitialize4from5countySpyxG_SitFSnySiG_Tgq5.exit", label %.sink.split.i

.sink.split.i:                                    ; preds = %37
  %44 = bitcast %Ts28__ContiguousArrayStorageBaseC* %38 to i8*
  %45 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %46 = shl nuw i64 %16, 4
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %45, i8* nonnull align 8 %44, i64 %46, i1 false)
  br label %"$sSp14moveInitialize4from5countySpyxG_SitFSnySiG_Tgq5.exit"

"$sSp14moveInitialize4from5countySpyxG_SitFSnySiG_Tgq5.exit": ; preds = %37, %.sink.split.i
  store i64 0, i64* %._storage.count._value, align 8
  br label %47

47:                                               ; preds = %"$sSp14moveInitialize4from5countySpyxG_SitFSnySiG_Tgq5.exit", %32
  %48 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %48) #9
  ret %Ts28__ContiguousArrayStorageBaseC* %30

49:                                               ; preds = %8
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSnySiG_Tgq5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #5 {
entry:
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._storage.count._value, align 8, !range !6
  %2 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSnySiG_Tgq5"(i1 false, i64 %1, i1 false, %Ts28__ContiguousArrayStorageBaseC* %0)
  ret %Ts28__ContiguousArrayStorageBaseC* %2
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 %0, i64 %1, i1 %2, %Ts15ContiguousArrayV* nocapture swiftself dereferenceable(8) %3) local_unnamed_addr #5 {
entry:
  %._buffer._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %3, i64 0, i32 0, i32 0
  %4 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %5 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSS_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %4)
  store %Ts28__ContiguousArrayStorageBaseC* %5, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  ret void
}

; Function Attrs: minsize noinline optsize
define linkonce_odr hidden swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSi_Tg5"(i1 %0, i64 %1, i1 %2, %Ts15ContiguousArrayV* nocapture swiftself dereferenceable(8) %3) local_unnamed_addr #5 {
entry:
  %._buffer._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %3, i64 0, i32 0, i32 0
  %4 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %5 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %4)
  store %Ts28__ContiguousArrayStorageBaseC* %5, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  ret void
}

; Function Attrs: cold noreturn nounwind
declare void @llvm.trap() #6

; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
declare { i64, i1 } @llvm.ssub.with.overflow.i64(i64, i64) #7

; Function Attrs: mustprogress nounwind willreturn
declare zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted*) local_unnamed_addr #8

; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #7

; Function Attrs: nounwind
declare void @swift_release(%swift.refcounted*) local_unnamed_addr #9

; Function Attrs: argmemonly mustprogress nocallback nofree nosync nounwind willreturn
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1

; Function Attrs: nounwind
declare void @swift_beginAccess(i8*, [24 x i8]*, i64, i8*) local_unnamed_addr #9

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss15ContiguousArrayV9repeating5countAByxGx_SitcfCSi_Tgq5"(i64 %0, i64 %1) local_unnamed_addr #0 {
entry:
  %2 = icmp slt i64 %1, 0
  br i1 %2, label %15, label %3, !prof !7

3:                                                ; preds = %entry
  %.not = icmp eq i64 %1, 0
  br i1 %.not, label %.thread, label %4

4:                                                ; preds = %3
  %5 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss15ContiguousArrayV28_allocateBufferUninitialized15minimumCapacitys01_abD0VyxGSi_tFZ"(i64 %1, %swift.type* nonnull @"$sSiN")
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %5, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %1, i64* %._storage.count._value, align 8
  %6 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %5, i64 1
  %7 = bitcast %Ts28__ContiguousArrayStorageBaseC* %6 to %TSi*
  br label %8

8:                                                ; preds = %8, %4
  %9 = phi %TSi* [ %13, %8 ], [ %7, %4 ]
  %10 = phi i64 [ %11, %8 ], [ 0, %4 ]
  %11 = add nuw nsw i64 %10, 1
  %._value = getelementptr inbounds %TSi, %TSi* %9, i64 0, i32 0
  store i64 %0, i64* %._value, align 8
  %12 = icmp eq i64 %11, %1
  %13 = getelementptr inbounds %TSi, %TSi* %9, i64 1
  br i1 %12, label %.thread, label %8

.thread:                                          ; preds = %8, %3
  %14 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %3 ], [ %5, %8 ]
  ret %Ts28__ContiguousArrayStorageBaseC* %14

15:                                               ; preds = %entry
  tail call void asm sideeffect "", "n"(i32 0) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: minsize optsize
declare swiftcc void @"$ss15__VaListBuilderC6appendyys7CVarArg_pF"(%Ts7CVarArgP* noalias nocapture dereferenceable(40), %Ts15__VaListBuilderC* swiftself) local_unnamed_addr #0

; Function Attrs: minsize optsize
declare swiftcc void @"$ss15__VaListBuilderCfD"(%Ts15__VaListBuilderC* swiftself) local_unnamed_addr #0

; Function Attrs: minsize optsize
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss30_copySequenceToContiguousArrayys0dE0Vy7ElementQzGxSTRzlFs010EnumeratedB0VySaySi1l_Si1rtGG_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #0 {
entry:
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 1, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._storage.count._value, align 8, !range !6
  %2 = icmp eq i64 %1, 0
  br i1 %2, label %15, label %3

3:                                                ; preds = %entry
  %4 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %4 to <{ %TSi, %TSi }>*
  %5 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %0, i64 0, i32 0
  %6 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %5) #27
  br label %7

7:                                                ; preds = %60, %3
  %8 = phi i64 [ 0, %3 ], [ %61, %60 ]
  %9 = phi <{ %TSi, <{ %TSi, %TSi }> }>* [ bitcast (%struct.HeapMetadata** getelementptr inbounds (%struct._SwiftEmptyArrayStorage, %struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage, i64 1, i32 0, i32 0) to <{ %TSi, <{ %TSi, %TSi }> }>*), %3 ], [ %65, %60 ]
  %10 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %3 ], [ %57, %60 ]
  %11 = phi i64 [ 0, %3 ], [ %62, %60 ]
  %.l._value = getelementptr inbounds <{ %TSi, %TSi }>, <{ %TSi, %TSi }>* %tailaddr, i64 %11, i32 0, i32 0
  %12 = bitcast i64* %.l._value to <2 x i64>*
  %13 = load <2 x i64>, <2 x i64>* %12, align 8
  %14 = icmp eq i64 %8, 0
  br i1 %14, label %20, label %54

15:                                               ; preds = %entry, %66
  %16 = phi i64 [ %67, %66 ], [ 0, %entry ]
  %17 = phi %Ts28__ContiguousArrayStorageBaseC* [ %57, %66 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %entry ]
  %._storage1._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %17, i64 0, i32 1, i32 0, i32 1, i32 0
  %18 = load i64, i64* %._storage1._capacityAndFlags._value, align 8
  %19 = icmp ult i64 %18, 2
  br i1 %19, label %77, label %71

20:                                               ; preds = %7
  %._storage2._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %10, i64 0, i32 1, i32 0, i32 1, i32 0
  %21 = load i64, i64* %._storage2._capacityAndFlags._value, align 8
  %22 = lshr i64 %21, 1
  %23 = add nuw i64 %22, 4611686018427387904
  %24 = icmp slt i64 %23, 0
  br i1 %24, label %80, label %25, !prof !7

25:                                               ; preds = %20
  %26 = and i64 %21, -2
  %27 = tail call i64 @llvm.smax.i64(i64 %26, i64 1)
  %28 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCySi6offset_Si1l_Si1rt7elementtGMD") #28
  %29 = mul i64 %27, 24
  %30 = add i64 %29, 32
  %31 = tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %28, i64 %30, i64 7) #9
  %32 = bitcast %swift.refcounted* %31 to %Ts28__ContiguousArrayStorageBaseC*
  %33 = bitcast %swift.refcounted* %31 to i8*
  %call.i = tail call i64 @malloc_usable_size(i8* noundef %33) #30
  %gepdiff = add nsw i64 %call.i, -32
  %34 = sdiv i64 %gepdiff, 24
  %35 = shl nsw i64 %34, 1
  %36 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %31, i64 1
  %._storage9.count._value = bitcast %swift.refcounted* %36 to i64*
  store i64 %27, i64* %._storage9.count._value, align 8
  %._storage9._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %31, i64 1, i32 1
  store i64 %35, i64* %._storage9._capacityAndFlags, align 8
  %37 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %31, i64 2
  %38 = bitcast %swift.refcounted* %37 to i8*
  %tailaddr4 = bitcast %swift.refcounted* %37 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %39 = load i64, i64* %._storage2._capacityAndFlags._value, align 8
  %40 = lshr i64 %39, 1
  %41 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr4, i64 %40
  %42 = and i64 %34, 9223372036854775807
  %43 = sub nsw i64 %42, %40
  %._storage2.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %10, i64 0, i32 1, i32 0, i32 0, i32 0
  %44 = load i64, i64* %._storage2.count._value, align 8, !range !6
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %.sink.split, label %46

46:                                               ; preds = %25
  %47 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %10, i64 1
  %tailaddr6 = bitcast %Ts28__ContiguousArrayStorageBaseC* %47 to <{ %TSi, <{ %TSi, %TSi }> }>*
  %48 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %47, i64 0, i32 0
  %49 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %tailaddr6, i64 %40
  %50 = bitcast <{ %TSi, <{ %TSi, %TSi }> }>* %49 to %swift.refcounted*
  %51 = icmp ult %swift.refcounted* %37, %50
  %52 = icmp eq %swift.refcounted* %37, %48
  %or.cond27 = select i1 %52, i1 %51, i1 false
  br i1 %or.cond27, label %70, label %.sink.split26

.sink.split:                                      ; preds = %25, %70
  %53 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %10, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %53) #9
  br label %54

54:                                               ; preds = %.sink.split, %7
  %55 = phi i64 [ %8, %7 ], [ %43, %.sink.split ]
  %56 = phi <{ %TSi, <{ %TSi, %TSi }> }>* [ %9, %7 ], [ %41, %.sink.split ]
  %57 = phi %Ts28__ContiguousArrayStorageBaseC* [ %10, %7 ], [ %32, %.sink.split ]
  %58 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %55, i64 -1)
  %59 = extractvalue { i64, i1 } %58, 1
  br i1 %59, label %78, label %60, !prof !7

60:                                               ; preds = %54
  %61 = extractvalue { i64, i1 } %58, 0
  %62 = add nuw nsw i64 %11, 1
  %.offset._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %56, i64 0, i32 0, i32 0
  store i64 %11, i64* %.offset._value, align 8
  %.element.l._value = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %56, i64 0, i32 1, i32 0, i32 0
  %63 = bitcast i64* %.element.l._value to <2 x i64>*
  store <2 x i64> %13, <2 x i64>* %63, align 8
  %64 = icmp eq i64 %62, %1
  %65 = getelementptr inbounds <{ %TSi, <{ %TSi, %TSi }> }>, <{ %TSi, <{ %TSi, %TSi }> }>* %56, i64 1
  br i1 %64, label %66, label %7

66:                                               ; preds = %60
  tail call void @swift_release(%swift.refcounted* %5) #9
  %67 = extractvalue { i64, i1 } %58, 0
  br label %15

.sink.split26:                                    ; preds = %46
  %68 = bitcast %Ts28__ContiguousArrayStorageBaseC* %47 to i8*
  %69 = mul nuw i64 %40, 24
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %38, i8* nonnull align 8 %68, i64 %69, i1 false)
  br label %70

70:                                               ; preds = %46, %.sink.split26
  store i64 0, i64* %._storage2.count._value, align 8
  br label %.sink.split

71:                                               ; preds = %15
  %72 = lshr i64 %18, 1
  %73 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 %72, i64 %16)
  %74 = extractvalue { i64, i1 } %73, 1
  br i1 %74, label %79, label %75, !prof !7

75:                                               ; preds = %71
  %76 = extractvalue { i64, i1 } %73, 0
  %._storage1.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %17, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %76, i64* %._storage1.count._value, align 8
  br label %77

77:                                               ; preds = %15, %75
  ret %Ts28__ContiguousArrayStorageBaseC* %17

78:                                               ; preds = %54
  tail call void asm sideeffect "", "n"(i32 1) #9
  tail call void @llvm.trap()
  unreachable

79:                                               ; preds = %71
  tail call void asm sideeffect "", "n"(i32 2) #9
  tail call void @llvm.trap()
  unreachable

80:                                               ; preds = %20
  tail call void asm sideeffect "", "n"(i32 3) #9
  tail call void @llvm.trap()
  unreachable
}

; Function Attrs: mustprogress nounwind willreturn
declare %swift.refcounted* @swift_retain(%swift.refcounted* returned) local_unnamed_addr #8

; Function Attrs: nounwind
declare void @swift_endAccess([24 x i8]*) local_unnamed_addr #9

; Function Attrs: minsize mustprogress nofree noinline nounwind optsize readonly willreturn
define linkonce_odr hidden %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* %0) local_unnamed_addr #10 {
entry:
  %1 = bitcast { i32, i32 }* %0 to i64*
  %2 = load atomic i64, i64* %1 monotonic, align 8
  %3 = icmp slt i64 %2, 0
  br i1 %3, label %7, label %4, !prof !7

4:                                                ; preds = %7, %entry
  %5 = phi i64 [ %2, %entry ], [ %15, %7 ]
  %6 = inttoptr i64 %5 to %swift.type*
  ret %swift.type* %6

7:                                                ; preds = %entry
  %8 = ashr i64 %2, 32
  %9 = sub nsw i64 0, %8
  %sext = shl i64 %2, 32
  %10 = ashr exact i64 %sext, 32
  %11 = ptrtoint { i32, i32 }* %0 to i64
  %12 = add i64 %10, %11
  %13 = inttoptr i64 %12 to i8*
  %14 = tail call swiftcc %swift.type* @swift_getTypeByMangledNameInContext2(i8* %13, i64 %9, %swift.type_descriptor* null, i8** null) #31
  %15 = ptrtoint %swift.type* %14 to i64
  store atomic i64 %15, i64* %1 monotonic, align 8
  br label %4
}

; Function Attrs: argmemonly nounwind
declare swiftcc %swift.type* @swift_getTypeByMangledNameInContext2(i8*, i64, %swift.type_descriptor*, i8**) local_unnamed_addr #11

; Function Attrs: nounwind
declare %swift.refcounted* @swift_allocObject(%swift.type*, i64, i64) local_unnamed_addr #9

; Function Attrs: minsize optsize
declare swiftcc { i64, %swift.bridge* } @"$ss23CustomStringConvertibleP11descriptionSSvgTj"(%swift.opaque* noalias nocapture swiftself, %swift.type*, i8**) local_unnamed_addr #0

; Function Attrs: minsize optsize
declare swiftcc { i64, %swift.bridge* } @"$sSKsSS7ElementRtzrlE6joined9separatorS2S_tF"(i64, %swift.bridge*, %swift.type*, i8**, %swift.opaque* noalias nocapture swiftself) local_unnamed_addr #0

; Function Attrs: minsize mustprogress nofree noinline nounwind optsize readonly willreturn
define linkonce_odr hidden %swift.type* @__swift_instantiateConcreteTypeFromMangledNameAbstract({ i32, i32 }* %0) local_unnamed_addr #10 {
entry:
  %1 = bitcast { i32, i32 }* %0 to i64*
  %2 = load atomic i64, i64* %1 monotonic, align 8
  %3 = icmp slt i64 %2, 0
  br i1 %3, label %7, label %4, !prof !7

4:                                                ; preds = %7, %entry
  %5 = phi i64 [ %2, %entry ], [ %15, %7 ]
  %6 = inttoptr i64 %5 to %swift.type*
  ret %swift.type* %6

7:                                                ; preds = %entry
  %8 = ashr i64 %2, 32
  %9 = sub nsw i64 0, %8
  %sext = shl i64 %2, 32
  %10 = ashr exact i64 %sext, 32
  %11 = ptrtoint { i32, i32 }* %0 to i64
  %12 = add i64 %10, %11
  %13 = inttoptr i64 %12 to i8*
  %14 = tail call swiftcc %swift.type* @swift_getTypeByMangledNameInContextInMetadataState2(i64 255, i8* %13, i64 %9, %swift.type_descriptor* null, i8** null) #31
  %15 = ptrtoint %swift.type* %14 to i64
  store atomic i64 %15, i64* %1 monotonic, align 8
  br label %4
}

; Function Attrs: argmemonly nounwind
declare swiftcc %swift.type* @swift_getTypeByMangledNameInContextInMetadataState2(i64, i8*, i64, %swift.type_descriptor*, i8**) local_unnamed_addr #11

; Function Attrs: nofree nounwind readonly
declare i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor*, %swift.type*, i8***) local_unnamed_addr #12

; Function Attrs: minsize optsize
declare swiftcc void @"$ss5print_9separator10terminatoryypd_S2StF"(%Ts28__ContiguousArrayStorageBaseC*, i64, %swift.bridge*, i64, %swift.bridge*) local_unnamed_addr #0

; Function Attrs: nofree nounwind optsize
declare noundef i8* @fgets(i8* noundef, i32 noundef, %struct._IO_FILE* nocapture noundef) local_unnamed_addr #13

; Function Attrs: nounwind
declare void @swift_slowDealloc(i8*, i64, i64) local_unnamed_addr #9

; Function Attrs: nounwind
declare i8* @swift_slowAlloc(i64, i64) local_unnamed_addr #9

; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
declare { i64, i1 } @llvm.smul.with.overflow.i64(i64, i64) #7

; Function Attrs: mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn
declare { i32, i1 } @llvm.smul.with.overflow.i32(i32, i32) #7

; Function Attrs: mustprogress nounwind willreturn
declare %swift.refcounted* @swift_initStackObject(%swift.type*, %swift.refcounted*) local_unnamed_addr #8

; Function Attrs: minsize nofree noinline nosync nounwind optsize readnone
define internal i8** @"$sSaySSGSayxGSKsWlTm"(i8*** %0, { i32, i32 }* %1, %swift.protocol_conformance_descriptor* %2) local_unnamed_addr #14 {
entry:
  %3 = load i8**, i8*** %0, align 8
  %4 = icmp eq i8** %3, null
  br i1 %4, label %cacheIsNull, label %cont

cacheIsNull:                                      ; preds = %entry
  %5 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledNameAbstract({ i32, i32 }* nonnull %1) #28
  %6 = tail call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* nonnull %2, %swift.type* %5, i8*** undef) #28
  store atomic i8** %6, i8*** %0 release, align 8
  br label %cont

cont:                                             ; preds = %cacheIsNull, %entry
  %7 = phi i8** [ %3, %entry ], [ %6, %cacheIsNull ]
  ret i8** %7
}

; Function Attrs: minsize optsize
declare swiftcc %swift.metadata_response @"$ss15__VaListBuilderCMa"(i64) local_unnamed_addr #0

; Function Attrs: minsize optsize
declare swiftcc i64 @"$ss17_countGPRegistersSivg"() local_unnamed_addr #0

; Function Attrs: minsize optsize
declare swiftcc i64 @"$ss18_registerSaveWordsSivg"() local_unnamed_addr #0

; Function Attrs: minsize optsize
declare swiftcc void @"$sSS6appendyySSF"(i64, %swift.bridge*, %TSS* nocapture swiftself dereferenceable(16)) local_unnamed_addr #0

; Function Attrs: nounwind
declare void @swift_bridgeObjectRelease(%swift.bridge*) local_unnamed_addr #9

; Function Attrs: minsize optsize
declare swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSS11utf8CStrings15ContiguousArrayVys4Int8VGvg"(i64, %swift.bridge*) local_unnamed_addr #0

; Function Attrs: optsize
declare i32 @__isoc99_vfscanf(%struct._IO_FILE* noundef, i8* noundef, %struct.__va_list_tag* noundef) local_unnamed_addr #15

; Function Attrs: mustprogress nounwind willreturn
declare void @swift_setDeallocating(%swift.refcounted*) local_unnamed_addr #8

; Function Attrs: minsize optsize
declare swiftcc { i64, %swift.bridge* } @"$sSS7cStringSSSPys4Int8VG_tcfC"(i8*) local_unnamed_addr #0

; Function Attrs: minsize mustprogress nofree noinline nosync nounwind optsize readnone willreturn
define hidden swiftcc %swift.metadata_response @"$s7llvm_OZ11FenwickTreeVMa"(i64 %0, %swift.type* readnone %1) #16 {
entry:
  %2 = bitcast %swift.type* %1 to i8*
  %3 = tail call swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata(i64 %0, i8* %2, i8* undef, i8* undef, %swift.type_descriptor* nonnull bitcast (<{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8 }>* @"$s7llvm_OZ11FenwickTreeVMn" to %swift.type_descriptor*)) #29
  ret %swift.metadata_response %3
}

; Function Attrs: minsize optsize
declare swiftcc %swift.metadata_response @"$sSaMa"(i64, %swift.type*) local_unnamed_addr #0

; Function Attrs: minsize nounwind optsize
define internal %swift.type* @"$s7llvm_OZ11FenwickTreeVMi"(%swift.type_descriptor* %0, i8** %1, i8* %2) #17 {
entry:
  %3 = tail call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_descriptor* %0, i8** %1, i8* %2, i64 32) #9
  ret %swift.type* %3
}

; Function Attrs: minsize nounwind optsize
define internal swiftcc %swift.metadata_response @"$s7llvm_OZ11FenwickTreeVMr"(%swift.type* %"FenwickTree<Element>", i8* nocapture readnone %0, i8** nocapture readnone %1) #17 {
entry:
  %classFields = alloca [5 x i8**], align 8
  %2 = bitcast [5 x i8**]* %classFields to i8*
  call void @llvm.lifetime.start.p0i8(i64 40, i8* nonnull %2)
  %3 = getelementptr inbounds [5 x i8**], [5 x i8**]* %classFields, i64 0, i64 0
  store i8** getelementptr (i8*, i8** @"$sBi64_WV", i64 8), i8*** %3, align 8
  %4 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %5 = bitcast %swift.type* %4 to %swift.type**
  %Element = load %swift.type*, %swift.type** %5, align 8, !invariant.load !9
  %6 = tail call swiftcc %swift.metadata_response @swift_checkMetadataState(i64 319, %swift.type* %Element) #32
  %7 = extractvalue %swift.metadata_response %6, 0
  %8 = extractvalue %swift.metadata_response %6, 1
  %9 = icmp ult i64 %8, 64
  br i1 %9, label %dependency-satisfied, label %metadata-dependencies.cont

dependency-satisfied:                             ; preds = %entry
  %10 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 3
  %11 = bitcast %swift.type* %10 to i32*
  %12 = getelementptr inbounds %swift.type, %swift.type* %7, i64 -1
  %13 = bitcast %swift.type* %12 to i8***
  %.valueWitnesses = load i8**, i8*** %13, align 8, !invariant.load !9, !dereferenceable !10
  %14 = getelementptr inbounds i8*, i8** %.valueWitnesses, i64 8
  %15 = getelementptr inbounds [5 x i8**], [5 x i8**]* %classFields, i64 0, i64 1
  store i8** %14, i8*** %15, align 8
  %16 = getelementptr inbounds [5 x i8**], [5 x i8**]* %classFields, i64 0, i64 2
  store i8** getelementptr (i8*, i8** @"$sBoWV", i64 8), i8*** %16, align 8
  %17 = getelementptr inbounds [5 x i8**], [5 x i8**]* %classFields, i64 0, i64 3
  store i8** getelementptr (i8*, i8** @"$syycWV", i64 8), i8*** %17, align 8
  %18 = getelementptr inbounds [5 x i8**], [5 x i8**]* %classFields, i64 0, i64 4
  store i8** getelementptr (i8*, i8** @"$syycWV", i64 8), i8*** %18, align 8
  call void @swift_initStructMetadata(%swift.type* nonnull %"FenwickTree<Element>", i64 0, i64 5, i8*** nonnull %3, i32* nonnull %11) #9
  call void @llvm.lifetime.end.p0i8(i64 40, i8* nonnull %2)
  br label %metadata-dependencies.cont

metadata-dependencies.cont:                       ; preds = %dependency-satisfied, %entry
  %19 = phi %swift.type* [ %7, %entry ], [ null, %dependency-satisfied ]
  %20 = phi i64 [ 63, %entry ], [ 0, %dependency-satisfied ]
  %21 = insertvalue %swift.metadata_response undef, %swift.type* %19, 0
  %22 = insertvalue %swift.metadata_response %21, i64 %20, 1
  ret %swift.metadata_response %22
}

; Function Attrs: minsize nounwind optsize
define internal %swift.opaque* @"$s7llvm_OZ11FenwickTreeVwCP"([24 x i8]* noalias %dest, [24 x i8]* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %0 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %1 = bitcast %swift.type* %0 to %swift.type**
  %Element = load %swift.type*, %swift.type** %1, align 8, !invariant.load !9
  %2 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %3 = bitcast %swift.type* %2 to i8***
  %Element.valueWitnesses = load i8**, i8*** %3, align 8, !invariant.load !9, !dereferenceable !10
  %4 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %5 = bitcast i8** %4 to i32*
  %flags = load i32, i32* %5, align 8, !invariant.load !9
  %6 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %6 to i64
  %7 = xor i64 %flags.alignmentMask, -1
  %8 = add nuw nsw i64 %flags.alignmentMask, 8
  %9 = and i64 %8, %7
  %10 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %11 = bitcast i8** %10 to i64*
  %size = load i64, i64* %11, align 8, !invariant.load !9
  %12 = add i64 %size, 7
  %13 = add i64 %12, %9
  %14 = and i64 %13, -8
  %15 = add i64 %14, 15
  %16 = and i64 %15, -8
  %17 = add i64 %16, 23
  %18 = and i64 %17, -8
  %size1 = add i64 %18, 16
  %19 = and i32 %flags, 1048576
  %flags.isBitwiseTakable = icmp eq i32 %19, 0
  %20 = icmp ult i32 %6, 8
  %21 = icmp ult i64 %size1, 25
  %22 = and i1 %flags.isBitwiseTakable, %21
  %23 = and i1 %20, %22
  br i1 %23, label %inlineBB, label %allocateBB

inlineBB:                                         ; preds = %entry
  %24 = bitcast [24 x i8]* %src to i64*
  %25 = bitcast [24 x i8]* %dest to i64*
  %26 = load i64, i64* %24, align 8
  store i64 %26, i64* %25, align 8
  %27 = ptrtoint [24 x i8]* %dest to i64
  %28 = ptrtoint [24 x i8]* %src to i64
  %29 = add i64 %8, %27
  %30 = and i64 %29, %7
  %31 = inttoptr i64 %30 to %swift.opaque*
  %32 = add i64 %8, %28
  %33 = and i64 %32, %7
  %34 = inttoptr i64 %33 to %swift.opaque*
  %35 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 2
  %36 = bitcast i8** %35 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %37 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %36, align 8, !invariant.load !9
  %38 = tail call %swift.opaque* %37(%swift.opaque* noalias %31, %swift.opaque* noalias %34, %swift.type* nonnull %Element) #9
  %39 = add i64 %12, %30
  %40 = and i64 %39, -8
  %41 = add i64 %12, %33
  %42 = and i64 %41, -8
  %43 = inttoptr i64 %40 to %TSa*
  %44 = inttoptr i64 %42 to %TSa*
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %43, i64 0, i32 0, i32 0
  %._buffer4._storage = getelementptr inbounds %TSa, %TSa* %44, i64 0, i32 0, i32 0
  %45 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer4._storage, align 8
  %46 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %45, i64 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %45, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %47 = add i64 %40, 15
  %48 = and i64 %47, -8
  %49 = add i64 %42, 15
  %50 = and i64 %49, -8
  %51 = inttoptr i64 %48 to %swift.function*
  %52 = inttoptr i64 %50 to %swift.function*
  %.fn = getelementptr inbounds %swift.function, %swift.function* %52, i64 0, i32 0
  %.fn.load = load i8*, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %52, i64 0, i32 1
  %53 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  %.fn5 = getelementptr inbounds %swift.function, %swift.function* %51, i64 0, i32 0
  store i8* %.fn.load, i8** %.fn5, align 8
  %.data6 = getelementptr inbounds %swift.function, %swift.function* %51, i64 0, i32 1
  store %swift.refcounted* %53, %swift.refcounted** %.data6, align 8
  %54 = add i64 %48, 23
  %55 = and i64 %54, -8
  %56 = add i64 %50, 23
  %57 = and i64 %56, -8
  %58 = inttoptr i64 %55 to %swift.function*
  %59 = inttoptr i64 %57 to %swift.function*
  %.fn7 = getelementptr inbounds %swift.function, %swift.function* %59, i64 0, i32 0
  %.fn7.load = load i8*, i8** %.fn7, align 8
  %.data8 = getelementptr inbounds %swift.function, %swift.function* %59, i64 0, i32 1
  %60 = load %swift.refcounted*, %swift.refcounted** %.data8, align 8
  %.fn9 = getelementptr inbounds %swift.function, %swift.function* %58, i64 0, i32 0
  store i8* %.fn7.load, i8** %.fn9, align 8
  %.data10 = getelementptr inbounds %swift.function, %swift.function* %58, i64 0, i32 1
  store %swift.refcounted* %60, %swift.refcounted** %.data10, align 8
  %61 = bitcast [24 x i8]* %dest to %swift.opaque*
  %62 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %46) #27
  %63 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %53) #27
  br label %74

allocateBB:                                       ; preds = %entry
  %64 = bitcast [24 x i8]* %dest to %swift.refcounted**
  %65 = bitcast [24 x i8]* %src to %swift.refcounted**
  %66 = load %swift.refcounted*, %swift.refcounted** %65, align 8
  store %swift.refcounted* %66, %swift.refcounted** %64, align 8
  %67 = add nuw nsw i64 %flags.alignmentMask, 16
  %68 = and i64 %flags.alignmentMask, 248
  %69 = xor i64 %68, 504
  %70 = and i64 %69, %67
  %71 = bitcast %swift.refcounted* %66 to i8*
  %72 = getelementptr inbounds i8, i8* %71, i64 %70
  %73 = bitcast i8* %72 to %swift.opaque*
  br label %74

74:                                               ; preds = %allocateBB, %inlineBB
  %.sink = phi %swift.refcounted* [ %66, %allocateBB ], [ %60, %inlineBB ]
  %75 = phi %swift.opaque* [ %73, %allocateBB ], [ %61, %inlineBB ]
  %76 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %.sink) #27
  ret %swift.opaque* %75
}

; Function Attrs: argmemonly mustprogress nocallback nofree nounwind willreturn
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #19

; Function Attrs: minsize nounwind optsize
define internal void @"$s7llvm_OZ11FenwickTreeVwxx"(%swift.opaque* noalias %object, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %0 = ptrtoint %swift.opaque* %object to i64
  %1 = add i64 %0, 8
  %2 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %3 = bitcast %swift.type* %2 to %swift.type**
  %Element = load %swift.type*, %swift.type** %3, align 8, !invariant.load !9
  %4 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %5 = bitcast %swift.type* %4 to i8***
  %Element.valueWitnesses = load i8**, i8*** %5, align 8, !invariant.load !9, !dereferenceable !10
  %6 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %7 = bitcast i8** %6 to i32*
  %flags = load i32, i32* %7, align 8, !invariant.load !9
  %8 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %8 to i64
  %9 = add i64 %1, %flags.alignmentMask
  %10 = xor i64 %flags.alignmentMask, -1
  %11 = and i64 %9, %10
  %12 = inttoptr i64 %11 to %swift.opaque*
  %13 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %14 = bitcast i8** %13 to void (%swift.opaque*, %swift.type*)**
  %15 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %14, align 8, !invariant.load !9
  tail call void %15(%swift.opaque* noalias %12, %swift.type* %Element) #9
  %16 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %17 = bitcast i8** %16 to i64*
  %size = load i64, i64* %17, align 8, !invariant.load !9
  %18 = add i64 %size, 7
  %19 = add i64 %18, %11
  %20 = and i64 %19, -8
  %21 = inttoptr i64 %20 to %TSa*
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %21, i64 0, i32 0, i32 0
  %toDestroy = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %22 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %toDestroy, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %22) #9
  %23 = add i64 %20, 15
  %24 = and i64 %23, -8
  %25 = inttoptr i64 %24 to %swift.function*
  %.data = getelementptr inbounds %swift.function, %swift.function* %25, i64 0, i32 1
  %26 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  tail call void @swift_release(%swift.refcounted* %26) #9
  %27 = add i64 %24, 23
  %28 = and i64 %27, -8
  %29 = inttoptr i64 %28 to %swift.function*
  %.data1 = getelementptr inbounds %swift.function, %swift.function* %29, i64 0, i32 1
  %30 = load %swift.refcounted*, %swift.refcounted** %.data1, align 8
  tail call void @swift_release(%swift.refcounted* %30) #9
  ret void
}

; Function Attrs: minsize nounwind optsize
define internal %swift.opaque* @"$s7llvm_OZ11FenwickTreeVwcp"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %0 = bitcast %swift.opaque* %src to i64*
  %1 = bitcast %swift.opaque* %dest to i64*
  %2 = load i64, i64* %0, align 8
  store i64 %2, i64* %1, align 8
  %3 = ptrtoint %swift.opaque* %dest to i64
  %4 = ptrtoint %swift.opaque* %src to i64
  %5 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %6 = bitcast %swift.type* %5 to %swift.type**
  %Element = load %swift.type*, %swift.type** %6, align 8, !invariant.load !9
  %7 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %8 = bitcast %swift.type* %7 to i8***
  %Element.valueWitnesses = load i8**, i8*** %8, align 8, !invariant.load !9, !dereferenceable !10
  %9 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %10 = bitcast i8** %9 to i32*
  %flags = load i32, i32* %10, align 8, !invariant.load !9
  %11 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %11 to i64
  %12 = add nuw nsw i64 %flags.alignmentMask, 8
  %13 = add i64 %12, %3
  %14 = xor i64 %flags.alignmentMask, -1
  %15 = and i64 %13, %14
  %16 = inttoptr i64 %15 to %swift.opaque*
  %17 = add i64 %12, %4
  %18 = and i64 %17, %14
  %19 = inttoptr i64 %18 to %swift.opaque*
  %20 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 2
  %21 = bitcast i8** %20 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %22 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %21, align 8, !invariant.load !9
  %23 = tail call %swift.opaque* %22(%swift.opaque* noalias %16, %swift.opaque* noalias %19, %swift.type* %Element) #9
  %24 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %25 = bitcast i8** %24 to i64*
  %size = load i64, i64* %25, align 8, !invariant.load !9
  %26 = add i64 %size, 7
  %27 = add i64 %26, %15
  %28 = and i64 %27, -8
  %29 = add i64 %26, %18
  %30 = and i64 %29, -8
  %31 = inttoptr i64 %28 to %TSa*
  %32 = inttoptr i64 %30 to %TSa*
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %31, i64 0, i32 0, i32 0
  %._buffer1._storage = getelementptr inbounds %TSa, %TSa* %32, i64 0, i32 0, i32 0
  %33 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer1._storage, align 8
  %34 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %33, i64 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %33, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %35 = add i64 %28, 15
  %36 = and i64 %35, -8
  %37 = add i64 %30, 15
  %38 = and i64 %37, -8
  %39 = inttoptr i64 %36 to %swift.function*
  %40 = inttoptr i64 %38 to %swift.function*
  %.fn = getelementptr inbounds %swift.function, %swift.function* %40, i64 0, i32 0
  %.fn.load = load i8*, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %40, i64 0, i32 1
  %41 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  %.fn2 = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 0
  store i8* %.fn.load, i8** %.fn2, align 8
  %.data3 = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 1
  store %swift.refcounted* %41, %swift.refcounted** %.data3, align 8
  %42 = add i64 %36, 23
  %43 = and i64 %42, -8
  %44 = add i64 %38, 23
  %45 = and i64 %44, -8
  %46 = inttoptr i64 %43 to %swift.function*
  %47 = inttoptr i64 %45 to %swift.function*
  %.fn4 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 0
  %.fn4.load = load i8*, i8** %.fn4, align 8
  %.data5 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 1
  %48 = load %swift.refcounted*, %swift.refcounted** %.data5, align 8
  %.fn6 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 0
  store i8* %.fn4.load, i8** %.fn6, align 8
  %.data7 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 1
  store %swift.refcounted* %48, %swift.refcounted** %.data7, align 8
  %49 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %34) #27
  %50 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %41) #27
  %51 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %48) #27
  ret %swift.opaque* %dest
}

; Function Attrs: minsize nounwind optsize
define internal %swift.opaque* @"$s7llvm_OZ11FenwickTreeVwca"(%swift.opaque* returned %dest, %swift.opaque* %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %._value = bitcast %swift.opaque* %dest to i64*
  %._value1 = bitcast %swift.opaque* %src to i64*
  %0 = load i64, i64* %._value1, align 8
  store i64 %0, i64* %._value, align 8
  %1 = ptrtoint %swift.opaque* %dest to i64
  %2 = ptrtoint %swift.opaque* %src to i64
  %3 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %4 = bitcast %swift.type* %3 to %swift.type**
  %Element = load %swift.type*, %swift.type** %4, align 8, !invariant.load !9
  %5 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %6 = bitcast %swift.type* %5 to i8***
  %Element.valueWitnesses = load i8**, i8*** %6, align 8, !invariant.load !9, !dereferenceable !10
  %7 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %8 = bitcast i8** %7 to i32*
  %flags = load i32, i32* %8, align 8, !invariant.load !9
  %9 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %9 to i64
  %10 = add nuw nsw i64 %flags.alignmentMask, 8
  %11 = add i64 %10, %1
  %12 = xor i64 %flags.alignmentMask, -1
  %13 = and i64 %11, %12
  %14 = inttoptr i64 %13 to %swift.opaque*
  %15 = add i64 %10, %2
  %16 = and i64 %15, %12
  %17 = inttoptr i64 %16 to %swift.opaque*
  %18 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 3
  %19 = bitcast i8** %18 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %20 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %19, align 8, !invariant.load !9
  %21 = tail call %swift.opaque* %20(%swift.opaque* %14, %swift.opaque* %17, %swift.type* %Element) #9
  %22 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %23 = bitcast i8** %22 to i64*
  %size = load i64, i64* %23, align 8, !invariant.load !9
  %24 = add i64 %size, 7
  %25 = add i64 %24, %13
  %26 = and i64 %25, -8
  %27 = add i64 %24, %16
  %28 = and i64 %27, -8
  %29 = inttoptr i64 %26 to %TSa*
  %30 = inttoptr i64 %28 to %TSa*
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %29, i64 0, i32 0, i32 0
  %._buffer2._storage = getelementptr inbounds %TSa, %TSa* %30, i64 0, i32 0, i32 0
  %31 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer2._storage, align 8
  %32 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %31, i64 0, i32 0
  %oldValue = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  store %Ts28__ContiguousArrayStorageBaseC* %31, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %33 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %oldValue, i64 0, i32 0
  %34 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %32) #27
  tail call void @swift_release(%swift.refcounted* %33) #9
  %35 = add i64 %26, 15
  %36 = and i64 %35, -8
  %37 = add i64 %28, 15
  %38 = and i64 %37, -8
  %39 = inttoptr i64 %36 to %swift.function*
  %40 = inttoptr i64 %38 to %swift.function*
  %.fn = getelementptr inbounds %swift.function, %swift.function* %40, i64 0, i32 0
  %.fn.load = load i8*, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %40, i64 0, i32 1
  %41 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  %.fn3 = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 0
  store i8* %.fn.load, i8** %.fn3, align 8
  %.data4 = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 1
  %42 = load %swift.refcounted*, %swift.refcounted** %.data4, align 8
  store %swift.refcounted* %41, %swift.refcounted** %.data4, align 8
  %43 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %41) #27
  tail call void @swift_release(%swift.refcounted* %42) #9
  %44 = add i64 %36, 23
  %45 = and i64 %44, -8
  %46 = add i64 %38, 23
  %47 = and i64 %46, -8
  %48 = inttoptr i64 %45 to %swift.function*
  %49 = inttoptr i64 %47 to %swift.function*
  %.fn5 = getelementptr inbounds %swift.function, %swift.function* %49, i64 0, i32 0
  %.fn5.load = load i8*, i8** %.fn5, align 8
  %.data6 = getelementptr inbounds %swift.function, %swift.function* %49, i64 0, i32 1
  %50 = load %swift.refcounted*, %swift.refcounted** %.data6, align 8
  %.fn7 = getelementptr inbounds %swift.function, %swift.function* %48, i64 0, i32 0
  store i8* %.fn5.load, i8** %.fn7, align 8
  %.data8 = getelementptr inbounds %swift.function, %swift.function* %48, i64 0, i32 1
  %51 = load %swift.refcounted*, %swift.refcounted** %.data8, align 8
  store %swift.refcounted* %50, %swift.refcounted** %.data8, align 8
  %52 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %50) #27
  tail call void @swift_release(%swift.refcounted* %51) #9
  ret %swift.opaque* %dest
}

; Function Attrs: minsize nounwind optsize
define internal %swift.opaque* @"$s7llvm_OZ11FenwickTreeVwtk"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %0 = bitcast %swift.opaque* %src to i64*
  %1 = bitcast %swift.opaque* %dest to i64*
  %2 = load i64, i64* %0, align 8
  store i64 %2, i64* %1, align 8
  %3 = ptrtoint %swift.opaque* %dest to i64
  %4 = ptrtoint %swift.opaque* %src to i64
  %5 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %6 = bitcast %swift.type* %5 to %swift.type**
  %Element = load %swift.type*, %swift.type** %6, align 8, !invariant.load !9
  %7 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %8 = bitcast %swift.type* %7 to i8***
  %Element.valueWitnesses = load i8**, i8*** %8, align 8, !invariant.load !9, !dereferenceable !10
  %9 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %10 = bitcast i8** %9 to i32*
  %flags = load i32, i32* %10, align 8, !invariant.load !9
  %11 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %11 to i64
  %12 = add nuw nsw i64 %flags.alignmentMask, 8
  %13 = add i64 %12, %3
  %14 = xor i64 %flags.alignmentMask, -1
  %15 = and i64 %13, %14
  %16 = inttoptr i64 %15 to %swift.opaque*
  %17 = add i64 %12, %4
  %18 = and i64 %17, %14
  %19 = inttoptr i64 %18 to %swift.opaque*
  %20 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %21 = bitcast i8** %20 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %22 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %21, align 8, !invariant.load !9
  %23 = tail call %swift.opaque* %22(%swift.opaque* noalias %16, %swift.opaque* noalias %19, %swift.type* %Element) #9
  %24 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %25 = bitcast i8** %24 to i64*
  %size = load i64, i64* %25, align 8, !invariant.load !9
  %26 = add i64 %size, 7
  %27 = add i64 %26, %15
  %28 = and i64 %27, -8
  %29 = add i64 %26, %18
  %30 = and i64 %29, -8
  %31 = inttoptr i64 %30 to i64*
  %32 = inttoptr i64 %28 to i64*
  %33 = load i64, i64* %31, align 8
  store i64 %33, i64* %32, align 8
  %34 = add i64 %28, 15
  %35 = and i64 %34, -8
  %36 = add i64 %30, 15
  %37 = and i64 %36, -8
  %38 = inttoptr i64 %35 to %swift.function*
  %39 = inttoptr i64 %37 to %swift.function*
  %.fn = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 0
  %40 = load i8*, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %39, i64 0, i32 1
  %41 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  %.fn1 = getelementptr inbounds %swift.function, %swift.function* %38, i64 0, i32 0
  store i8* %40, i8** %.fn1, align 8
  %.data2 = getelementptr inbounds %swift.function, %swift.function* %38, i64 0, i32 1
  store %swift.refcounted* %41, %swift.refcounted** %.data2, align 8
  %42 = add i64 %35, 23
  %43 = and i64 %42, -8
  %44 = add i64 %37, 23
  %45 = and i64 %44, -8
  %46 = inttoptr i64 %43 to %swift.function*
  %47 = inttoptr i64 %45 to %swift.function*
  %.fn3 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 0
  %48 = load i8*, i8** %.fn3, align 8
  %.data4 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 1
  %49 = load %swift.refcounted*, %swift.refcounted** %.data4, align 8
  %.fn5 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 0
  store i8* %48, i8** %.fn5, align 8
  %.data6 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 1
  store %swift.refcounted* %49, %swift.refcounted** %.data6, align 8
  ret %swift.opaque* %dest
}

; Function Attrs: minsize nounwind optsize
define internal %swift.opaque* @"$s7llvm_OZ11FenwickTreeVwta"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %._value = bitcast %swift.opaque* %dest to i64*
  %._value1 = bitcast %swift.opaque* %src to i64*
  %0 = load i64, i64* %._value1, align 8
  store i64 %0, i64* %._value, align 8
  %1 = ptrtoint %swift.opaque* %dest to i64
  %2 = ptrtoint %swift.opaque* %src to i64
  %3 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %4 = bitcast %swift.type* %3 to %swift.type**
  %Element = load %swift.type*, %swift.type** %4, align 8, !invariant.load !9
  %5 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %6 = bitcast %swift.type* %5 to i8***
  %Element.valueWitnesses = load i8**, i8*** %6, align 8, !invariant.load !9, !dereferenceable !10
  %7 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 10
  %8 = bitcast i8** %7 to i32*
  %flags = load i32, i32* %8, align 8, !invariant.load !9
  %9 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %9 to i64
  %10 = add nuw nsw i64 %flags.alignmentMask, 8
  %11 = add i64 %10, %1
  %12 = xor i64 %flags.alignmentMask, -1
  %13 = and i64 %11, %12
  %14 = inttoptr i64 %13 to %swift.opaque*
  %15 = add i64 %10, %2
  %16 = and i64 %15, %12
  %17 = inttoptr i64 %16 to %swift.opaque*
  %18 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 5
  %19 = bitcast i8** %18 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %20 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %19, align 8, !invariant.load !9
  %21 = tail call %swift.opaque* %20(%swift.opaque* noalias %14, %swift.opaque* noalias %17, %swift.type* %Element) #9
  %22 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %23 = bitcast i8** %22 to i64*
  %size = load i64, i64* %23, align 8, !invariant.load !9
  %24 = add i64 %size, 7
  %25 = add i64 %24, %13
  %26 = and i64 %25, -8
  %27 = add i64 %24, %16
  %28 = and i64 %27, -8
  %29 = inttoptr i64 %26 to %TSa*
  %30 = inttoptr i64 %28 to %TSa*
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %29, i64 0, i32 0, i32 0
  %._buffer2._storage = getelementptr inbounds %TSa, %TSa* %30, i64 0, i32 0, i32 0
  %31 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer2._storage, align 8
  %oldValue = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  store %Ts28__ContiguousArrayStorageBaseC* %31, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %32 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %oldValue, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %32) #9
  %33 = add i64 %26, 15
  %34 = and i64 %33, -8
  %35 = add i64 %28, 15
  %36 = and i64 %35, -8
  %37 = inttoptr i64 %34 to %swift.function*
  %38 = inttoptr i64 %36 to %swift.function*
  %.fn = getelementptr inbounds %swift.function, %swift.function* %38, i64 0, i32 0
  %39 = load i8*, i8** %.fn, align 8
  %.data = getelementptr inbounds %swift.function, %swift.function* %38, i64 0, i32 1
  %40 = load %swift.refcounted*, %swift.refcounted** %.data, align 8
  %.fn3 = getelementptr inbounds %swift.function, %swift.function* %37, i64 0, i32 0
  store i8* %39, i8** %.fn3, align 8
  %.data4 = getelementptr inbounds %swift.function, %swift.function* %37, i64 0, i32 1
  %41 = load %swift.refcounted*, %swift.refcounted** %.data4, align 8
  store %swift.refcounted* %40, %swift.refcounted** %.data4, align 8
  tail call void @swift_release(%swift.refcounted* %41) #9
  %42 = add i64 %34, 23
  %43 = and i64 %42, -8
  %44 = add i64 %36, 23
  %45 = and i64 %44, -8
  %46 = inttoptr i64 %43 to %swift.function*
  %47 = inttoptr i64 %45 to %swift.function*
  %.fn5 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 0
  %48 = load i8*, i8** %.fn5, align 8
  %.data6 = getelementptr inbounds %swift.function, %swift.function* %47, i64 0, i32 1
  %49 = load %swift.refcounted*, %swift.refcounted** %.data6, align 8
  %.fn7 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 0
  store i8* %48, i8** %.fn7, align 8
  %.data8 = getelementptr inbounds %swift.function, %swift.function* %46, i64 0, i32 1
  %50 = load %swift.refcounted*, %swift.refcounted** %.data8, align 8
  store %swift.refcounted* %49, %swift.refcounted** %.data8, align 8
  tail call void @swift_release(%swift.refcounted* %50) #9
  ret %swift.opaque* %dest
}

; Function Attrs: minsize nofree nounwind optsize readonly
define internal i32 @"$s7llvm_OZ11FenwickTreeVwet"(%swift.opaque* noalias %value, i32 %numEmptyCases, %swift.type* nocapture readonly %"FenwickTree<Element>") #20 {
entry:
  %0 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %1 = bitcast %swift.type* %0 to %swift.type**
  %Element = load %swift.type*, %swift.type** %1, align 8, !invariant.load !9
  %2 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %3 = bitcast %swift.type* %2 to %swift.vwtable**
  %Element.valueWitnesses12 = load %swift.vwtable*, %swift.vwtable** %3, align 8, !invariant.load !9, !dereferenceable !10
  %4 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses12, i64 0, i32 11
  %extraInhabitantCount = load i32, i32* %4, align 4, !invariant.load !9
  %5 = tail call i32 @llvm.umax.i32(i32 %extraInhabitantCount, i32 4096)
  %6 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses12, i64 0, i32 10
  %flags = load i32, i32* %6, align 8, !invariant.load !9
  %7 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %7 to i64
  %8 = xor i64 %flags.alignmentMask, -1
  %9 = add nuw nsw i64 %flags.alignmentMask, 8
  %10 = and i64 %9, %8
  %11 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses12, i64 0, i32 8
  %size = load i64, i64* %11, align 8, !invariant.load !9
  %12 = add i64 %size, 7
  %13 = add i64 %12, %10
  %14 = and i64 %13, -8
  %15 = add i64 %14, 15
  %16 = and i64 %15, -8
  %17 = add i64 %16, 23
  %18 = and i64 %17, -8
  %size1 = add i64 %18, 16
  %19 = trunc i64 %size1 to i32
  %20 = icmp eq i32 %numEmptyCases, 0
  br i1 %20, label %found_max_xi, label %21

21:                                               ; preds = %entry
  %22 = icmp ult i32 %5, %numEmptyCases
  br i1 %22, label %23, label %.thread

23:                                               ; preds = %21
  %24 = icmp ugt i32 %19, 3
  %25 = add i32 %numEmptyCases, 1
  %26 = sub i32 %25, %5
  %num-tags-phi = select i1 %24, i32 2, i32 %26
  %27 = icmp ult i32 %num-tags-phi, 2
  %28 = icmp ult i32 %num-tags-phi, 256
  %29 = icmp ult i32 %num-tags-phi, 65536
  %30 = select i1 %29, i32 2, i32 4
  %31 = select i1 %28, i32 1, i32 %30
  %num-tag-bytes = select i1 %27, i32 0, i32 %31
  %32 = bitcast %swift.opaque* %value to i8*
  %33 = getelementptr inbounds i8, i8* %32, i64 %size1
  switch i32 %num-tag-bytes, label %44 [
    i32 0, label %.thread
    i32 1, label %34
    i32 2, label %37
    i32 4, label %41
  ]

34:                                               ; preds = %23
  %35 = load i8, i8* %33, align 1
  %36 = zext i8 %35 to i32
  br label %45

37:                                               ; preds = %23
  %38 = bitcast i8* %33 to i16*
  %39 = load i16, i16* %38, align 1
  %40 = zext i16 %39 to i32
  br label %45

41:                                               ; preds = %23
  %42 = bitcast i8* %33 to i32*
  %43 = load i32, i32* %42, align 1
  br label %45

44:                                               ; preds = %23
  unreachable

45:                                               ; preds = %41, %37, %34
  %46 = phi i32 [ %36, %34 ], [ %40, %37 ], [ %43, %41 ]
  %47 = icmp eq i32 %46, 0
  br i1 %47, label %.thread, label %48

48:                                               ; preds = %45
  %49 = add i32 %46, -1
  %50 = select i1 %24, i32 0, i32 %49
  %.not = icmp eq i32 %19, 0
  br i1 %.not, label %54, label %51

51:                                               ; preds = %48
  %52 = bitcast %swift.opaque* %value to i32*
  %53 = load i32, i32* %52, align 8
  br label %54

54:                                               ; preds = %51, %48
  %55 = phi i32 [ 0, %48 ], [ %53, %51 ]
  %56 = or i32 %55, %50
  %57 = add nuw i32 %5, 1
  %58 = add i32 %57, %56
  br label %found_max_xi

.thread:                                          ; preds = %23, %45, %21
  %59 = ptrtoint %swift.opaque* %value to i64
  %60 = add i64 %9, %59
  %61 = and i64 %60, %8
  %62 = icmp ugt i32 %extraInhabitantCount, 4095
  br i1 %62, label %63, label %is-valid-pointer

63:                                               ; preds = %.thread
  %64 = inttoptr i64 %61 to %swift.opaque*
  %65 = tail call i32 @__swift_getEnumTagSinglePayload(%swift.opaque* %64, i32 %extraInhabitantCount, %swift.type* nonnull %Element)
  br label %found_max_xi

is-valid-pointer:                                 ; preds = %.thread
  %66 = add i64 %12, %61
  %67 = and i64 %66, -8
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68, align 8
  %70 = icmp ugt i64 %69, 4095
  %71 = trunc i64 %69 to i32
  %.op = add i32 %71, 1
  %72 = select i1 %70, i32 0, i32 %.op
  br label %found_max_xi

found_max_xi:                                     ; preds = %entry, %is-valid-pointer, %63, %54
  %73 = phi i32 [ %58, %54 ], [ %65, %63 ], [ %72, %is-valid-pointer ], [ 0, %entry ]
  ret i32 %73
}

; Function Attrs: minsize nofree noinline nounwind optsize readonly
define linkonce_odr hidden i32 @__swift_getEnumTagSinglePayload(%swift.opaque* %0, i32 %1, %swift.type* %2) local_unnamed_addr #21 {
entry:
  %3 = getelementptr inbounds %swift.type, %swift.type* %2, i64 -1
  %4 = bitcast %swift.type* %3 to i8***
  %.valueWitnesses = load i8**, i8*** %4, align 8, !invariant.load !9, !dereferenceable !10
  %5 = getelementptr inbounds i8*, i8** %.valueWitnesses, i64 6
  %6 = bitcast i8** %5 to i32 (%swift.opaque*, i32, %swift.type*)**
  %7 = load i32 (%swift.opaque*, i32, %swift.type*)*, i32 (%swift.opaque*, i32, %swift.type*)** %6, align 8, !invariant.load !9
  %8 = tail call i32 %7(%swift.opaque* noalias %0, i32 %1, %swift.type* %2) #28
  ret i32 %8
}

; Function Attrs: minsize nounwind optsize
define internal void @"$s7llvm_OZ11FenwickTreeVwst"(%swift.opaque* noalias %value, i32 %whichCase, i32 %numEmptyCases, %swift.type* nocapture readonly %"FenwickTree<Element>") #18 {
entry:
  %0 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 2
  %1 = bitcast %swift.type* %0 to %swift.type**
  %Element = load %swift.type*, %swift.type** %1, align 8, !invariant.load !9
  %2 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %3 = bitcast %swift.type* %2 to %swift.vwtable**
  %Element.valueWitnesses8 = load %swift.vwtable*, %swift.vwtable** %3, align 8, !invariant.load !9, !dereferenceable !10
  %4 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses8, i64 0, i32 11
  %extraInhabitantCount = load i32, i32* %4, align 4, !invariant.load !9
  %5 = tail call i32 @llvm.umax.i32(i32 %extraInhabitantCount, i32 4096)
  %6 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses8, i64 0, i32 10
  %flags = load i32, i32* %6, align 8, !invariant.load !9
  %7 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %7 to i64
  %8 = xor i64 %flags.alignmentMask, -1
  %9 = add nuw nsw i64 %flags.alignmentMask, 8
  %10 = and i64 %9, %8
  %11 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %Element.valueWitnesses8, i64 0, i32 8
  %size = load i64, i64* %11, align 8, !invariant.load !9
  %12 = add i64 %size, 7
  %13 = add i64 %12, %10
  %14 = and i64 %13, -8
  %15 = add i64 %14, 15
  %16 = and i64 %15, -8
  %17 = add i64 %16, 23
  %18 = and i64 %17, -8
  %size1 = add i64 %18, 16
  %19 = trunc i64 %size1 to i32
  %20 = bitcast %swift.opaque* %value to i8*
  %21 = getelementptr inbounds i8, i8* %20, i64 %size1
  %22 = icmp ult i32 %5, %numEmptyCases
  br i1 %22, label %23, label %32

23:                                               ; preds = %entry
  %24 = icmp ugt i32 %19, 3
  %25 = add i32 %numEmptyCases, 1
  %26 = sub i32 %25, %5
  %num-tags-phi = select i1 %24, i32 2, i32 %26
  %27 = icmp ult i32 %num-tags-phi, 2
  %28 = icmp ult i32 %num-tags-phi, 256
  %29 = icmp ult i32 %num-tags-phi, 65536
  %30 = select i1 %29, i32 2, i32 4
  %31 = select i1 %28, i32 1, i32 %30
  %num-tag-bytes = select i1 %27, i32 0, i32 %31
  br label %32

32:                                               ; preds = %23, %entry
  %33 = phi i32 [ 0, %entry ], [ %num-tag-bytes, %23 ]
  %.not = icmp ult i32 %5, %whichCase
  br i1 %.not, label %60, label %34

34:                                               ; preds = %32
  switch i32 %33, label %40 [
    i32 0, label %41
    i32 1, label %35
    i32 2, label %36
    i32 4, label %38
  ]

35:                                               ; preds = %34
  store i8 0, i8* %21, align 1
  br label %41

36:                                               ; preds = %34
  %37 = bitcast i8* %21 to i16*
  store i16 0, i16* %37, align 1
  br label %41

38:                                               ; preds = %34
  %39 = bitcast i8* %21 to i32*
  store i32 0, i32* %39, align 1
  br label %41

40:                                               ; preds = %34
  unreachable

41:                                               ; preds = %34, %38, %36, %35
  %.not10 = icmp eq i32 %whichCase, 0
  br i1 %.not10, label %found_max_xi, label %42

42:                                               ; preds = %41
  %43 = ptrtoint %swift.opaque* %value to i64
  %44 = add i64 %9, %43
  %45 = and i64 %44, %8
  %46 = icmp ugt i32 %extraInhabitantCount, 4095
  br i1 %46, label %47, label %49

47:                                               ; preds = %42
  %48 = inttoptr i64 %45 to %swift.opaque*
  tail call void @__swift_storeEnumTagSinglePayload(%swift.opaque* %48, i32 %whichCase, i32 %extraInhabitantCount, %swift.type* nonnull %Element)
  br label %found_max_xi

49:                                               ; preds = %42
  %50 = add i64 %12, %45
  %51 = and i64 %50, -8
  %52 = icmp ult i32 %whichCase, 4097
  %53 = inttoptr i64 %51 to i64*
  br i1 %52, label %54, label %57

54:                                               ; preds = %49
  %55 = add nsw i32 %whichCase, -1
  %56 = zext i32 %55 to i64
  store i64 %56, i64* %53, align 8
  br label %found_max_xi

57:                                               ; preds = %49
  %58 = add i32 %whichCase, -4097
  %59 = zext i32 %58 to i64
  store i64 %59, i64* %53, align 8
  br label %found_max_xi

60:                                               ; preds = %32
  %61 = icmp ugt i32 %19, 3
  %62 = sub i32 %whichCase, %5
  %spec.select = select i1 %61, i32 1, i32 %62
  %.not9 = icmp eq i32 %19, 0
  br i1 %.not9, label %67, label %63

63:                                               ; preds = %60
  %64 = xor i32 %5, -1
  %65 = add i32 %64, %whichCase
  %spec.select12 = select i1 %61, i32 %65, i32 0
  tail call void @llvm.memset.p0i8.i32(i8* align 8 %20, i8 0, i32 %19, i1 false)
  %66 = bitcast %swift.opaque* %value to i32*
  store i32 %spec.select12, i32* %66, align 8
  br label %67

67:                                               ; preds = %63, %60
  switch i32 %33, label %75 [
    i32 0, label %found_max_xi
    i32 1, label %68
    i32 2, label %70
    i32 4, label %73
  ]

68:                                               ; preds = %67
  %69 = trunc i32 %spec.select to i8
  store i8 %69, i8* %21, align 1
  br label %found_max_xi

70:                                               ; preds = %67
  %71 = trunc i32 %spec.select to i16
  %72 = bitcast i8* %21 to i16*
  store i16 %71, i16* %72, align 1
  br label %found_max_xi

73:                                               ; preds = %67
  %74 = bitcast i8* %21 to i32*
  store i32 %spec.select, i32* %74, align 1
  br label %found_max_xi

75:                                               ; preds = %67
  unreachable

found_max_xi:                                     ; preds = %57, %68, %70, %73, %67, %54, %47, %41
  ret void
}

; Function Attrs: minsize noinline nounwind optsize
define linkonce_odr hidden void @__swift_storeEnumTagSinglePayload(%swift.opaque* %0, i32 %1, i32 %2, %swift.type* %3) local_unnamed_addr #22 {
entry:
  %4 = getelementptr inbounds %swift.type, %swift.type* %3, i64 -1
  %5 = bitcast %swift.type* %4 to i8***
  %.valueWitnesses = load i8**, i8*** %5, align 8, !invariant.load !9, !dereferenceable !10
  %6 = getelementptr inbounds i8*, i8** %.valueWitnesses, i64 7
  %7 = bitcast i8** %6 to void (%swift.opaque*, i32, i32, %swift.type*)**
  %8 = load void (%swift.opaque*, i32, i32, %swift.type*)*, void (%swift.opaque*, i32, i32, %swift.type*)** %7, align 8, !invariant.load !9
  tail call void %8(%swift.opaque* noalias %0, i32 %1, i32 %2, %swift.type* %3) #9
  ret void
}

; Function Attrs: argmemonly mustprogress nocallback nofree nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1 immarg) #23

; Function Attrs: nounwind
declare %swift.type* @swift_allocateGenericValueMetadata(%swift.type_descriptor*, i8**, i8*, i64) local_unnamed_addr #9

; Function Attrs: mustprogress nofree nounwind readonly willreturn
declare swiftcc %swift.metadata_response @swift_checkMetadataState(i64, %swift.type*) local_unnamed_addr #24

; Function Attrs: nounwind
declare void @swift_initStructMetadata(%swift.type*, i64, i64, i8***, i32*) local_unnamed_addr #9

; Function Attrs: nounwind
declare void @swift_arrayDestroy(%swift.opaque*, i64, %swift.type*) local_unnamed_addr #9

; Function Attrs: nounwind
declare void @swift_deallocClassInstance(%swift.refcounted*, i64, i64) local_unnamed_addr #9

; Function Attrs: minsize noinline optsize
declare swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss15ContiguousArrayV28_allocateBufferUninitialized15minimumCapacitys01_abD0VyxGSi_tFZ"(i64, %swift.type*) local_unnamed_addr #5

; Function Attrs: argmemonly mustprogress nocallback nofree nounwind willreturn
declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1 immarg) #19

; Function Attrs: mustprogress nounwind willreturn
declare void @swift_arrayInitWithCopy(%swift.opaque*, %swift.opaque*, i64, %swift.type*) local_unnamed_addr #8

; Function Attrs: minsize noinline optsize
declare swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64, %swift.type*) local_unnamed_addr #5

; Function Attrs: minsize mustprogress nofree noinline nounwind optsize readonly willreturn
define linkonce_odr hidden swiftcc %swift.metadata_response @__swift_instantiateGenericMetadata(i64 %0, i8* %1, i8* %2, i8* %3, %swift.type_descriptor* %4) local_unnamed_addr #10 {
entry:
  %generic.arguments = alloca [3 x i8*], align 8
  %5 = bitcast [3 x i8*]* %generic.arguments to i8*
  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %5)
  %6 = getelementptr inbounds [3 x i8*], [3 x i8*]* %generic.arguments, i64 0, i64 0
  store i8* %1, i8** %6, align 8
  %7 = getelementptr inbounds [3 x i8*], [3 x i8*]* %generic.arguments, i64 0, i64 1
  store i8* %2, i8** %7, align 8
  %8 = getelementptr inbounds [3 x i8*], [3 x i8*]* %generic.arguments, i64 0, i64 2
  store i8* %3, i8** %8, align 8
  %9 = call swiftcc %swift.metadata_response @swift_getGenericMetadata(i64 %0, i8* nonnull %5, %swift.type_descriptor* %4) #28
  ret %swift.metadata_response %9
}

; Function Attrs: nofree nounwind readonly
declare swiftcc %swift.metadata_response @swift_getGenericMetadata(i64, i8*, %swift.type_descriptor*) local_unnamed_addr #12

; Function Attrs: optsize
declare i64 @malloc_usable_size(i8* noundef) local_unnamed_addr #15

; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
declare i64 @llvm.smax.i64(i64, i64) #25

; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
declare i64 @llvm.smin.i64(i64, i64) #25

; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
declare i32 @llvm.umax.i32(i32, i32) #25

; Function Attrs: argmemonly nocallback nofree nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #26

; Function Attrs: nounwind
declare %swift.refcounted* @swift_retain_n(%swift.refcounted* returned, i32) #9

attributes #0 = { minsize optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { argmemonly mustprogress nocallback nofree nosync nounwind willreturn }
attributes #2 = { minsize mustprogress nofree norecurse nosync nounwind optsize readnone willreturn "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { minsize optsize sspreq "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { argmemonly minsize mustprogress nofree norecurse nosync nounwind optsize readonly willreturn "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { minsize noinline optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { cold noreturn nounwind }
attributes #7 = { mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn }
attributes #8 = { mustprogress nounwind willreturn }
attributes #9 = { nounwind }
attributes #10 = { minsize mustprogress nofree noinline nounwind optsize readonly willreturn "frame-pointer"="non-leaf" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #11 = { argmemonly nounwind }
attributes #12 = { nofree nounwind readonly }
attributes #13 = { nofree nounwind optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #14 = { minsize nofree noinline nosync nounwind optsize readnone "frame-pointer"="non-leaf" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #15 = { optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #16 = { minsize mustprogress nofree noinline nosync nounwind optsize readnone willreturn "frame-pointer"="non-leaf" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #17 = { minsize nounwind optsize "frame-pointer"="non-leaf" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #18 = { minsize nounwind optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #19 = { argmemonly mustprogress nocallback nofree nounwind willreturn }
attributes #20 = { minsize nofree nounwind optsize readonly "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #21 = { minsize nofree noinline nounwind optsize readonly "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #22 = { minsize noinline nounwind optsize "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx16,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #23 = { argmemonly mustprogress nocallback nofree nounwind willreturn writeonly }
attributes #24 = { mustprogress nofree nounwind readonly willreturn }
attributes #25 = { nocallback nofree nosync nounwind readnone speculatable willreturn }
attributes #26 = { argmemonly nocallback nofree nounwind willreturn writeonly }
attributes #27 = { nounwind willreturn }
attributes #28 = { nounwind readonly }
attributes #29 = { nounwind readnone }
attributes #30 = { nounwind optsize }
attributes #31 = { argmemonly nounwind readonly }
attributes #32 = { nounwind readonly willreturn }

!swift.module.flags = !{!0}
!llvm.linker.options = !{}
!llvm.module.flags = !{!1, !2, !3, !4, !5}

!0 = !{!"standard-library", i1 false}
!1 = !{i32 1, !"wchar_size", i32 4}
!2 = !{i32 8, !"PIC Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{i32 4, !"Objective-C Garbage Collection", i32 84477696}
!5 = !{i32 1, !"Swift Version", i32 7}
!6 = !{i64 0, i64 9223372036854775807}
!7 = !{!"branch_weights", i32 1, i32 2000}
!8 = !{!"branch_weights", i32 2000, i32 1}
!9 = !{}
!10 = !{i64 96}
