let (N, Q) = getIntPair()
let a = getInts(count: N)

var ft = FenwickTree(count: N)
for i in 0..<N { ft.update(at: i, adding: a[i]) }

var responses = [Int]()
for _ in 0..<Q {
    let (q0, q1, q2) = getIntTriplet()
    if q0 == 0 {
        let (p, x) = (q1, q2)
        ft.update(at: p, adding: x)
    }
    else {
        let (l, r) = (q1, q2)
        responses.append(ft.query(range: l..<r))
    }
}

print(responses.map(String.init).joined(separator: "\n"))




//=============================================================================
// MARK: - FenwickTree.swift
// code section by Barry Fam

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

    init(count: Int,
         zeroValue: Element,
         addBy combine: @escaping (Element, _ adding: Element) -> Element,
         removeBy inverse: @escaping (Element, _ removing: Element) -> Element
    ){
        tree = [Element](repeating: zeroValue, count: count)
        self.count = count
        self.zeroValue = zeroValue
        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)
        assert(r.count >= 1)
        var i = r.upperBound - 1
        var j = r.lowerBound - 1
        var sigma = zeroValue
        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
    }
}

extension FenwickTree where Element == Int {
    init(count: Int) {
        self.init(count: count, zeroValue: 0, addBy: (+), removeBy: (-))
    }
}

//=============================================================================
// MARK: - contestIO.swift
// code section by Barry Fam

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

struct IO {
    static var INPUT = stdin
    fileprivate static var buffer: UnsafeMutablePointer<CChar>?
    fileprivate static var bufferCapacity: Int32 = 0
}

fileprivate func getsToBuffer(size: Int32) -> UnsafeMutablePointer<CChar> {
    if IO.bufferCapacity < size {
        IO.buffer?.deallocate()
        IO.buffer = UnsafeMutablePointer.allocate(capacity: Int(size))
        IO.bufferCapacity = size
    }
    return fgets(IO.buffer!, size, IO.INPUT)
}
fileprivate 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 ~= d:
            x = (x ?? 0)*10 + Int(d)-0x30
        default:
            if x != nil { return minus ? -x! : x! }
            assert(ptr.pointee == 0x20)
        }
        ptr += 1
    }
}

func getString(maxLength: Int) -> String {
    var s = String(cString: getsToBuffer(size: Int32(maxLength + 3)))
    if s.last == "\n" { s.removeLast() }
    if s.last == "\r" { s.removeLast() }
    return s
}
func getStringAsArray(maxLength: Int) -> [UInt8] {
    let ptr = getsToBuffer(size: Int32(maxLength + 3))
    var s = [UInt8]()
    for ptr in ptr ..< ptr + maxLength {
        let c = UInt8(ptr.pointee)
        if c == 0x00 || c == 0x0A || c == 0x0D { break }
        s.append(c)
    }
    return s
}
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 getIntTriplet() -> (Int, Int, Int) {
    var xPtr = getsToBuffer(size: 3*24)
    let x1 = getIntFromBuffer(&xPtr)
    let x2 = getIntFromBuffer(&xPtr)
    let x3 = getIntFromBuffer(&xPtr)
    return (x1, x2, x3)
}
func getIntQuadruplet() -> (Int, Int, Int, Int) {
    var xPtr = getsToBuffer(size: 4*24)
    let x1 = getIntFromBuffer(&xPtr)
    let x2 = getIntFromBuffer(&xPtr)
    let x3 = getIntFromBuffer(&xPtr)
    let x4 = getIntFromBuffer(&xPtr)
    return (x1, x2, x3, x4)
}
func getIntQuintuplet() -> (Int, Int, Int, Int, Int) {
    var xPtr = getsToBuffer(size: 5*24)
    let x1 = getIntFromBuffer(&xPtr)
    let x2 = getIntFromBuffer(&xPtr)
    let x3 = getIntFromBuffer(&xPtr)
    let x4 = getIntFromBuffer(&xPtr)
    let x5 = getIntFromBuffer(&xPtr)
    return (x1, x2, x3, x4, x5)
}
func getIntSextuplet() -> (Int, Int, Int, Int, Int, Int) {
    var xPtr = getsToBuffer(size: 6*24)
    let x1 = getIntFromBuffer(&xPtr)
    let x2 = getIntFromBuffer(&xPtr)
    let x3 = getIntFromBuffer(&xPtr)
    let x4 = getIntFromBuffer(&xPtr)
    let x5 = getIntFromBuffer(&xPtr)
    let x6 = getIntFromBuffer(&xPtr)
    return (x1, x2, x3, x4, x5, x6)
}
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
}

; ModuleID = '/data/TheStack_IR/OJ_Samples/Collated/Swift/Source_2266/llvm_O3.ll'
source_filename = "/data/TheStack_IR/OJ_Samples/Collated/Swift/Source_2266/llvm_O3.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"

%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_O311FenwickTreeVySiG = type <{ %TSi, %TSi, %TSa, %swift.function, %swift.function }>
%swift.function = type { i8*, %swift.refcounted* }
%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
%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.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.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 }>
%T7llvm_O311FenwickTreeV = type <{ %TSi }>
%swift.metadata_response = type { %swift.type*, i64 }
%Ts5UInt8V = type <{ i8 }>
%Ts4Int8V = type <{ i8 }>

@"$s7llvm_O31NSivp" = hidden local_unnamed_addr global %TSi zeroinitializer, align 8
@"$s7llvm_O31QSivp" = hidden local_unnamed_addr global %TSi zeroinitializer, align 8
@"$s7llvm_O31aSaySiGvp" = hidden local_unnamed_addr global %TSa zeroinitializer, align 8
@"$s7llvm_O32ftAA11FenwickTreeVySiGvp" = hidden global %T7llvm_O311FenwickTreeVySiG zeroinitializer, align 8
@"$s7llvm_O39responsesSaySiGvp" = hidden global %TSa zeroinitializer, align 8
@"$s7llvm_O32IOV5INPUT_Wz" = internal global i64 0, align 8
@"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" = hidden global %TSpySo8_IO_FILEVGSg zeroinitializer, align 8
@stdin = external local_unnamed_addr global %struct._IO_FILE*, align 8
@"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_Wz" = internal global i64 0, align 8
@"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LLSpys4Int8VGSgvpZ.0" = internal unnamed_addr global i64 0, align 8
@"$s7llvm_O32IOV14bufferCapacity33_73E641EE209B6240D9CA5E4E565FCA33LLs5Int32VvpZ.0" = internal unnamed_addr global i32 0, align 4
@_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
@"\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_O311FenwickTreeVWV" = internal constant %swift.vwtable { i8* bitcast (%swift.opaque* ([24 x i8]*, [24 x i8]*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwCP" to i8*), i8* bitcast (void (%swift.opaque*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwxx" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwcp" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwca" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwtk" to i8*), i8* bitcast (%swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)* @"$s7llvm_O311FenwickTreeVwta" to i8*), i8* bitcast (i32 (%swift.opaque*, i32, %swift.type*)* @"$s7llvm_O311FenwickTreeVwet" to i8*), i8* bitcast (void (%swift.opaque*, i32, i32, %swift.type*)* @"$s7llvm_O311FenwickTreeVwst" to i8*), i64 0, i64 0, i32 4194304, i32 0 }, align 8
@.str.7.llvm_O3 = private constant [8 x i8] c"llvm_O3\00"
@"$s7llvm_O3MXM" = linkonce_odr hidden constant <{ i32, i32, i32 }> <{ i32 0, i32 0, i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.7.llvm_O3 to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32 }>, <{ i32, i32, i32 }>* @"$s7llvm_O3MXM", 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_O311FenwickTreeVMI" = internal global [16 x i8*] zeroinitializer, align 8
@"$s7llvm_O311FenwickTreeVMn" = 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_O3MXM" 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_O311FenwickTreeVMn", 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_O311FenwickTreeVMn", i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (%swift.metadata_response (i64, %swift.type*)* @"$s7llvm_O311FenwickTreeVMa" 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_O311FenwickTreeVMn", 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_O311FenwickTreeVMF" 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_O311FenwickTreeVMn", i32 0, i32 4) to i64)) to i32), i32 5, i32 3, i32 trunc (i64 sub (i64 ptrtoint ([16 x i8*]* @"$s7llvm_O311FenwickTreeVMI" 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_O311FenwickTreeVMn", i32 0, i32 7) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32 }>* @"$s7llvm_O311FenwickTreeVMP" 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_O311FenwickTreeVMn", 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_O311FenwickTreeVMP" = internal constant <{ i32, i32, i32, i32 }> <{ i32 trunc (i64 sub (i64 ptrtoint (%swift.type* (%swift.type_descriptor*, i8**, i8*)* @"$s7llvm_O311FenwickTreeVMi" to i64), i64 ptrtoint (<{ i32, i32, i32, i32 }>* @"$s7llvm_O311FenwickTreeVMP" to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (%swift.metadata_response (%swift.type*, i8*, i8**)* @"$s7llvm_O311FenwickTreeVMr" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32 }>, <{ i32, i32, i32, i32 }>* @"$s7llvm_O311FenwickTreeVMP", i32 0, i32 1) to i64)) to i32), i32 1073741824, i32 trunc (i64 sub (i64 ptrtoint (%swift.vwtable* @"$s7llvm_O311FenwickTreeVWV" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32 }>, <{ i32, i32, i32, i32 }>* @"$s7llvm_O311FenwickTreeVMP", i32 0, i32 3) to i64)) to i32) }>, align 8
@"symbolic _____ 7llvm_O311FenwickTreeV" = 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_O311FenwickTreeVMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, i8 }>, <{ i8, i32, i8 }>* @"symbolic _____ 7llvm_O311FenwickTreeV", 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 [10 x i8] c"zeroValue\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_O311FenwickTreeVMF" = 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_O311FenwickTreeV" 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_O311FenwickTreeVMF" 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", i32 0, i32 9) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([10 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", 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_O311FenwickTreeVMF", i32 0, i32 19) to i64)) to i32) }, section "swift5_fieldmd", no_sanitize_address, align 4
@"$sytWV" = external global i8*, align 8
@.str.2.IO = private constant [3 x i8] c"IO\00"
@"$s7llvm_O32IOVMn" = hidden constant <{ i32, i32, i32, i32, i32, i32, i32 }> <{ i32 81, i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32 }>* @"$s7llvm_O3MXM" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32 }>, <{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn", i32 0, i32 1) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.2.IO to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32 }>, <{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn", i32 0, i32 2) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (%swift.metadata_response (i64)* @"$s7llvm_O32IOVMa" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32 }>, <{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn", i32 0, i32 3) to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ({ i32, i32, i16, i16, i32 }* @"$s7llvm_O32IOVMF" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, i32 }>, <{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn", i32 0, i32 4) to i64)) to i32), i32 0, i32 2 }>, section ".rodata", no_sanitize_address, align 4
@"$s7llvm_O32IOVMf" = internal constant <{ i8*, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32 }>* }> <{ i8* null, i8** @"$sytWV", i64 512, <{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn" }>, align 8
@"symbolic _____ 7llvm_O32IOV" = linkonce_odr hidden constant <{ i8, i32, i8 }> <{ i8 1, i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, i8 }>, <{ i8, i32, i8 }>* @"symbolic _____ 7llvm_O32IOV", i32 0, i32 1) to i64)) to i32), i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$s7llvm_O32IOVMF" = internal constant { i32, i32, i16, i16, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, i8 }>* @"symbolic _____ 7llvm_O32IOV" to i64), i64 ptrtoint ({ i32, i32, i16, i16, i32 }* @"$s7llvm_O32IOVMF" to i64)) to i32), i32 0, i16 0, i16 12, i32 0 }, section "swift5_fieldmd", no_sanitize_address, align 4
@"$ss5UInt8VMn" = external global %swift.type_descriptor, align 4
@"got.$ss5UInt8VMn" = private unnamed_addr constant %swift.type_descriptor* @"$ss5UInt8VMn"
@"symbolic _____y_____G s23_ContiguousArrayStorageC s5UInt8V" = linkonce_odr hidden constant <{ i8, i32, [1 x i8], i8, i32, [1 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, [1 x i8], i8 }>, <{ i8, i32, [1 x i8], i8, i32, [1 x i8], i8 }>* @"symbolic _____y_____G s23_ContiguousArrayStorageC s5UInt8V", i32 0, i32 1) to i64)) to i32), [1 x i8] c"y", i8 2, i32 trunc (i64 sub (i64 ptrtoint (%swift.type_descriptor** @"got.$ss5UInt8VMn" to i64), i64 ptrtoint (i32* getelementptr inbounds (<{ i8, i32, [1 x i8], i8, i32, [1 x i8], i8 }>, <{ i8, i32, [1 x i8], i8, i32, [1 x i8], i8 }>* @"symbolic _____y_____G s23_ContiguousArrayStorageC s5UInt8V", i32 0, i32 4) to i64)) to i32), [1 x i8] c"G", i8 0 }>, section "swift5_typeref", no_sanitize_address, align 2
@"$ss23_ContiguousArrayStorageCys5UInt8VGMD" = linkonce_odr hidden global { i32, i32 } { i32 trunc (i64 sub (i64 ptrtoint (<{ i8, i32, [1 x i8], i8, i32, [1 x i8], i8 }>* @"symbolic _____y_____G s23_ContiguousArrayStorageC s5UInt8V" to i64), i64 ptrtoint ({ i32, i32 }* @"$ss23_ContiguousArrayStorageCys5UInt8VGMD" to i64)) to i32), i32 -12 }, 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 _____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
@"$s7llvm_O311FenwickTreeVHn" = 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_O311FenwickTreeVMn" to i64), i64 ptrtoint (%swift.type_metadata_record* @"$s7llvm_O311FenwickTreeVHn" to i64)) to i32) }, section "swift5_type_metadata", no_sanitize_address, align 4
@"$s7llvm_O32IOVHn" = private constant %swift.type_metadata_record { i32 trunc (i64 sub (i64 ptrtoint (<{ i32, i32, i32, i32, i32, i32, i32 }>* @"$s7llvm_O32IOVMn" to i64), i64 ptrtoint (%swift.type_metadata_record* @"$s7llvm_O32IOVHn" 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 [8 x i8*] [i8* bitcast ({ i32, i32 }* @"\01l_entry_point" to i8*), i8* bitcast (%swift.type_metadata_record* @"$s7llvm_O311FenwickTreeVHn" 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_O311FenwickTreeVMF" to i8*), i8* bitcast (%swift.type_metadata_record* @"$s7llvm_O32IOVHn" to i8*), i8* bitcast ({ i32, i32, i16, i16, i32 }* @"$s7llvm_O32IOVMF" 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"

@"$s7llvm_O32IOVN" = hidden alias %swift.type, bitcast (i64* getelementptr inbounds (<{ i8*, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32 }>* }>, <{ i8*, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32 }>* }>* @"$s7llvm_O32IOVMf", i32 0, i32 2) to %swift.type*)

define protected i32 @main(i32 %0, i8** nocapture readnone %1) #0 {
entry:
  %2 = alloca i64, align 8
  %tmpcast = bitcast i64* %2 to %TSa*
  %3 = alloca %T7llvm_O311FenwickTreeVySiG, align 8
  %access-scratch = alloca [24 x i8], align 8
  %access-scratch3 = alloca [24 x i8], align 8
  %access-scratch4 = alloca [24 x i8], align 8
  %access-scratch11 = alloca [24 x i8], align 8
  %4 = alloca %Ts15ContiguousArrayV, align 8
  %5 = alloca %TSi, align 8
  %6 = alloca %TSa, align 8
  %access-scratch24 = alloca [24 x i8], align 8
  %7 = bitcast i64* %2 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %7)
  %8 = bitcast %T7llvm_O311FenwickTreeVySiG* %3 to i8*
  call void @llvm.lifetime.start.p0i8(i64 56, i8* nonnull %8)
  %9 = tail call swiftcc { i64, i64 } @"$s7llvm_O310getIntPairSi_SityF"()
  %10 = extractvalue { i64, i64 } %9, 0
  %11 = extractvalue { i64, i64 } %9, 1
  store i64 %10, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_O31NSivp", i64 0, i32 0), align 8
  store i64 %11, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_O31QSivp", i64 0, i32 0), align 8
  %12 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$s7llvm_O37getInts5countSaySiGSi_tF"(i64 %10)
  store %Ts28__ContiguousArrayStorageBaseC* %12, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O31aSaySiGvp", i64 0, i32 0, i32 0), align 8
  %13 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_O31NSivp", i64 0, i32 0), align 8
  %14 = icmp slt i64 %13, 0
  br i1 %14, label %134, label %15, !prof !6

15:                                               ; preds = %entry
  %.not = icmp eq i64 %13, 0
  br i1 %.not, label %16, label %17

16:                                               ; preds = %15
  tail call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(16) bitcast (%T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp" to i8*), i8 0, i64 16, i1 false)
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 2, i32 0, i32 0), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu_" to i8*), i8** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 1), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu0_" to i8*), i8** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 1), align 8
  br label %34

17:                                               ; preds = %15
  %18 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64 %13, %swift.type* nonnull @"$sSiN")
  %._storage25.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %13, i64* %._storage25.count._value, align 8
  %19 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %18, i64 1
  %20 = bitcast %Ts28__ContiguousArrayStorageBaseC* %19 to i8*
  %21 = shl nuw i64 %13, 3
  tail call void @llvm.memset.p0i8.i64(i8* align 8 %20, i8 0, i64 %21, i1 false)
  store i64 %13, i64* getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 0, i32 0), align 8
  store i64 0, i64* getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 1, i32 0), align 8
  store %Ts28__ContiguousArrayStorageBaseC* %18, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 2, i32 0, i32 0), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu_" to i8*), i8** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 3, i32 1), align 8
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu0_" to i8*), i8** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 0), align 8
  store %swift.refcounted* null, %swift.refcounted** getelementptr inbounds (%T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp", i64 0, i32 4, i32 1), align 8
  %22 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O31aSaySiGvp", i64 0, i32 0, i32 0), align 8
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %22, i64 0, i32 1, i32 0, i32 0, i32 0
  %23 = load i64, i64* %._storage.count._value, align 8, !range !7
  %24 = add nsw i64 %13, -1
  %.not39 = icmp ult i64 %24, %23
  br i1 %.not39, label %25, label %135, !prof !8

25:                                               ; preds = %17
  %26 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %22, i64 1
  %tailaddr1 = bitcast %Ts28__ContiguousArrayStorageBaseC* %26 to %TSi*
  %27 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %27)
  call void @swift_beginAccess(i8* nonnull bitcast (%T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp" to i8*), [24 x i8]* nonnull %access-scratch, i64 33, i8* null) #5
  br label %28

28:                                               ; preds = %28, %25
  %29 = phi i64 [ 0, %25 ], [ %30, %28 ]
  %30 = add nuw nsw i64 %29, 1
  %._value2 = getelementptr inbounds %TSi, %TSi* %tailaddr1, i64 %29, i32 0
  %31 = load i64, i64* %._value2, align 8
  call swiftcc void @"$s7llvm_O311FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %29, i64 %31, %T7llvm_O311FenwickTreeVySiG* nocapture nonnull swiftself dereferenceable(56) @"$s7llvm_O32ftAA11FenwickTreeVySiGvp")
  %32 = icmp eq i64 %30, %13
  br i1 %32, label %33, label %28

33:                                               ; preds = %28
  call void @swift_endAccess([24 x i8]* nonnull %access-scratch) #5
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %27)
  br label %34

34:                                               ; preds = %16, %33
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  %35 = load i64, i64* getelementptr inbounds (%TSi, %TSi* @"$s7llvm_O31QSivp", i64 0, i32 0), align 8
  %36 = icmp slt i64 %35, 0
  br i1 %36, label %136, label %37, !prof !6

37:                                               ; preds = %34
  %38 = icmp eq i64 %35, 0
  br i1 %38, label %.loopexit, label %39

39:                                               ; preds = %37
  %40 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch3, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %40)
  call void @swift_beginAccess(i8* nonnull bitcast (%T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp" to i8*), [24 x i8]* nonnull %access-scratch3, i64 0, i8* null) #5
  %41 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch4, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %41)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_O39responsesSaySiGvp" to i8*), [24 x i8]* nonnull %access-scratch4, i64 1, i8* null) #5
  %.tree = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %3, i64 0, i32 2
  %42 = bitcast %TSa* %.tree to i64*
  %.inverse.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %3, i64 0, i32 4, i32 1
  %.combine.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %3, i64 0, i32 3, i32 1
  %43 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch24, i64 0, i64 0
  br label %44

44:                                               ; preds = %52, %39
  %45 = phi i64 [ 0, %39 ], [ %53, %52 ]
  %46 = call swiftcc { i64, i64, i64 } @"$s7llvm_O313getIntTripletSi_S2ityF"()
  %47 = extractvalue { i64, i64, i64 } %46, 0
  %48 = extractvalue { i64, i64, i64 } %46, 1
  %49 = extractvalue { i64, i64, i64 } %46, 2
  %50 = icmp eq i64 %47, 0
  br i1 %50, label %51, label %55

51:                                               ; preds = %44
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %43)
  call void @swift_beginAccess(i8* nonnull bitcast (%T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp" to i8*), [24 x i8]* nonnull %access-scratch24, i64 33, i8* null) #5
  call swiftcc void @"$s7llvm_O311FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %48, i64 %49, %T7llvm_O311FenwickTreeVySiG* nocapture nonnull swiftself dereferenceable(56) @"$s7llvm_O32ftAA11FenwickTreeVySiGvp")
  call void @swift_endAccess([24 x i8]* nonnull %access-scratch24) #5
  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %43)
  br label %52

52:                                               ; preds = %51, %82
  %53 = add nuw nsw i64 %45, 1
  %54 = icmp eq i64 %53, %35
  br i1 %54, label %.loopexit, label %44

55:                                               ; preds = %44
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(56) %8, i8* noundef nonnull align 8 dereferenceable(56) bitcast (%T7llvm_O311FenwickTreeVySiG* @"$s7llvm_O32ftAA11FenwickTreeVySiGvp" to i8*), i64 56, i1 false)
  %56 = load i64, i64* %42, align 8
  store i64 %56, i64* %2, align 8
  %57 = icmp slt i64 %49, %48
  br i1 %57, label %137, label %58, !prof !6

58:                                               ; preds = %55
  %59 = load %swift.refcounted*, %swift.refcounted** %.inverse.data, align 8
  %60 = load %swift.refcounted*, %swift.refcounted** %.combine.data, align 8
  %61 = call %TSa* @"$sSaySiGWOr"(%TSa* nonnull %tmpcast)
  %62 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %60) #28
  %63 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %59) #28
  %64 = call swiftcc i64 @"$s7llvm_O311FenwickTreeV5query5rangexSnySiG_tFSi_Tg5"(i64 %48, i64 %49, %T7llvm_O311FenwickTreeVySiG* noalias nocapture nonnull swiftself dereferenceable(56) %3)
  %65 = call %TSa* @"$sSaySiGWOs"(%TSa* nonnull %tmpcast)
  call void @swift_release(%swift.refcounted* %59) #5
  call void @swift_release(%swift.refcounted* %60) #5
  %66 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  %67 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %66, i64 0, i32 0
  %68 = call zeroext i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %67) #28
  store %Ts28__ContiguousArrayStorageBaseC* %66, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  br i1 %68, label %73, label %69

69:                                               ; preds = %58
  %._storage5.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %66, i64 0, i32 1, i32 0, i32 0, i32 0
  %70 = load i64, i64* %._storage5.count._value, align 8, !range !7
  %71 = add nuw nsw i64 %70, 1
  %72 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 false, i64 %71, i1 true, %Ts28__ContiguousArrayStorageBaseC* %66)
  store %Ts28__ContiguousArrayStorageBaseC* %72, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  br label %73

73:                                               ; preds = %58, %69
  %74 = phi %Ts28__ContiguousArrayStorageBaseC* [ %66, %58 ], [ %72, %69 ]
  %._storage6.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %74, i64 0, i32 1, i32 0, i32 0, i32 0
  %75 = load i64, i64* %._storage6.count._value, align 8, !range !7
  %._storage6._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %74, i64 0, i32 1, i32 0, i32 1, i32 0
  %76 = load i64, i64* %._storage6._capacityAndFlags._value, align 8
  %77 = lshr i64 %76, 1
  %78 = add nuw nsw i64 %75, 1
  %.not40 = icmp ugt i64 %77, %75
  br i1 %.not40, label %82, label %79, !prof !8

79:                                               ; preds = %73
  %80 = icmp ugt i64 %76, 1
  %81 = call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 %80, i64 %78, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull %74)
  store %Ts28__ContiguousArrayStorageBaseC* %81, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  br label %82

82:                                               ; preds = %73, %79
  %83 = phi %Ts28__ContiguousArrayStorageBaseC* [ %74, %73 ], [ %81, %79 ]
  %._storage7.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %83, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %78, i64* %._storage7.count._value, align 8
  %84 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %83, i64 1
  %tailaddr8 = bitcast %Ts28__ContiguousArrayStorageBaseC* %84 to %TSi*
  %._value9 = getelementptr inbounds %TSi, %TSi* %tailaddr8, i64 %75, i32 0
  store i64 %64, i64* %._value9, align 8
  br label %52

.loopexit:                                        ; preds = %52, %37
  %85 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$ss23_ContiguousArrayStorageCyypGMD") #29
  %86 = call noalias %swift.refcounted* @swift_allocObject(%swift.type* %85, i64 64, i64 7) #5
  %87 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %86, i64 1
  %._storage10.count._value = bitcast %swift.refcounted* %87 to i64*
  store i64 1, i64* %._storage10.count._value, align 8
  %._storage10._capacityAndFlags = getelementptr inbounds %swift.refcounted, %swift.refcounted* %86, i64 1, i32 1
  store i64 2, i64* %._storage10._capacityAndFlags, align 8
  %88 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch11, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %88)
  call void @swift_beginAccess(i8* nonnull bitcast (%TSa* @"$s7llvm_O39responsesSaySiGvp" to i8*), [24 x i8]* nonnull %access-scratch11, i64 0, i8* null) #5
  %89 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** getelementptr inbounds (%TSa, %TSa* @"$s7llvm_O39responsesSaySiGvp", i64 0, i32 0, i32 0), align 8
  %._storage12.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %89, i64 0, i32 1, i32 0, i32 0, i32 0
  %90 = load i64, i64* %._storage12.count._value, align 8, !range !7
  %91 = icmp eq i64 %90, 0
  br i1 %91, label %100, label %92

92:                                               ; preds = %.loopexit
  %93 = bitcast %Ts15ContiguousArrayV* %4 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %93)
  %94 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %89, i64 0, i32 0
  %._buffer._storage = getelementptr inbounds %Ts15ContiguousArrayV, %Ts15ContiguousArrayV* %4, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %95 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %94) #28
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 false, i64 %90, i1 false, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %4)
  %96 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %97 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %89, i64 1
  %tailaddr14 = bitcast %Ts28__ContiguousArrayStorageBaseC* %97 to %TSi*
  %98 = bitcast %TSi* %5 to i8*
  %._value16 = getelementptr inbounds %TSi, %TSi* %5, i64 0, i32 0
  %99 = bitcast %TSi* %5 to %swift.opaque*
  br label %115

100:                                              ; preds = %.loopexit, %133
  %101 = phi %Ts28__ContiguousArrayStorageBaseC* [ %129, %133 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %.loopexit ]
  %102 = bitcast %swift.refcounted* %86 to %Ts28__ContiguousArrayStorageBaseC*
  %103 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %86, i64 2
  %104 = bitcast %TSa* %6 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %104)
  %._buffer22._storage = getelementptr inbounds %TSa, %TSa* %6, i64 0, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %101, %Ts28__ContiguousArrayStorageBaseC** %._buffer22._storage, align 8
  %105 = call %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* nonnull @"$sSaySSGMD") #29
  %106 = tail call i8** @"$sSaySSGSayxGSKsWl"() #30
  %107 = bitcast %TSa* %6 to %swift.opaque*
  %108 = call swiftcc { i64, %swift.bridge* } @"$sSKsSS7ElementRtzrlE6joined9separatorS2S_tF"(i64 10, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), %swift.type* %105, i8** %106, %swift.opaque* noalias nocapture nonnull swiftself %107)
  %109 = extractvalue { i64, %swift.bridge* } %108, 0
  %110 = extractvalue { i64, %swift.bridge* } %108, 1
  %111 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %101, i64 0, i32 0
  call void @swift_release(%swift.refcounted* %111) #5
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %104)
  %112 = getelementptr inbounds %swift.refcounted, %swift.refcounted* %86, i64 3, i32 1
  %113 = bitcast i64* %112 to %swift.type**
  store %swift.type* @"$sSSN", %swift.type** %113, align 8
  %._guts23._object._countAndFlagsBits._value = bitcast %swift.refcounted* %103 to i64*
  store i64 %109, i64* %._guts23._object._countAndFlagsBits._value, align 8
  %._guts23._object._object = getelementptr inbounds %swift.refcounted, %swift.refcounted* %86, i64 2, i32 1
  %114 = bitcast i64* %._guts23._object._object to %swift.bridge**
  store %swift.bridge* %110, %swift.bridge** %114, align 8
  call swiftcc void @"$ss5print_9separator10terminatoryypd_S2StF"(%Ts28__ContiguousArrayStorageBaseC* %102, 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* %86) #5
  call void @llvm.lifetime.end.p0i8(i64 56, i8* nonnull %8)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %7)
  ret i32 0

115:                                              ; preds = %128, %92
  %116 = phi i64 [ 0, %92 ], [ %130, %128 ]
  %117 = phi %Ts28__ContiguousArrayStorageBaseC* [ %96, %92 ], [ %129, %128 ]
  %._value15 = getelementptr inbounds %TSi, %TSi* %tailaddr14, i64 %116, i32 0
  %118 = load i64, i64* %._value15, align 8
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %98)
  store i64 %118, i64* %._value16, align 8
  %119 = call swiftcc { i64, %swift.bridge* } @"$ss23CustomStringConvertibleP11descriptionSSvgTj"(%swift.opaque* noalias nocapture nonnull swiftself %99, %swift.type* nonnull @"$sSiN", i8** nonnull @"$sSis23CustomStringConvertiblesWP")
  %120 = extractvalue { i64, %swift.bridge* } %119, 0
  %121 = extractvalue { i64, %swift.bridge* } %119, 1
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %98)
  store %Ts28__ContiguousArrayStorageBaseC* %117, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %._storage18.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %117, i64 0, i32 1, i32 0, i32 0, i32 0
  %122 = load i64, i64* %._storage18.count._value, align 8, !range !7
  %._storage18._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %117, i64 0, i32 1, i32 0, i32 1, i32 0
  %123 = load i64, i64* %._storage18._capacityAndFlags._value, align 8
  %124 = lshr i64 %123, 1
  %125 = add nuw nsw i64 %122, 1
  %.not41 = icmp ugt i64 %124, %122
  br i1 %.not41, label %128, label %126, !prof !8

126:                                              ; preds = %115
  %127 = icmp ugt i64 %123, 1
  call swiftcc void @"$ss15ContiguousArrayV16_createNewBuffer14bufferIsUnique15minimumCapacity13growForAppendySb_SiSbtFSS_Tg5"(i1 %127, i64 %125, i1 true, %Ts15ContiguousArrayV* nocapture nonnull swiftself dereferenceable(8) %4)
  %.pre = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  br label %128

128:                                              ; preds = %115, %126
  %129 = phi %Ts28__ContiguousArrayStorageBaseC* [ %117, %115 ], [ %.pre, %126 ]
  %130 = add nuw nsw i64 %116, 1
  %._storage19.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %129, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %125, i64* %._storage19.count._value, align 8
  %131 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %129, i64 1
  %tailaddr20 = bitcast %Ts28__ContiguousArrayStorageBaseC* %131 to %TSS*
  %._guts._object._countAndFlagsBits._value = getelementptr inbounds %TSS, %TSS* %tailaddr20, i64 %122, i32 0, i32 0, i32 0, i32 0
  store i64 %120, i64* %._guts._object._countAndFlagsBits._value, align 8
  %._guts._object._object = getelementptr inbounds %TSS, %TSS* %tailaddr20, i64 %122, i32 0, i32 0, i32 1
  store %swift.bridge* %121, %swift.bridge** %._guts._object._object, align 8
  %132 = icmp eq i64 %130, %90
  br i1 %132, label %133, label %115

133:                                              ; preds = %128
  call void @swift_release(%swift.refcounted* %94) #5
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %93)
  br label %100

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

135:                                              ; preds = %17
  tail call void asm sideeffect "", "n"(i32 2) #5
  tail call void @llvm.trap()
  unreachable

136:                                              ; preds = %34
  call void asm sideeffect "", "n"(i32 3) #5
  call void @llvm.trap()
  unreachable

137:                                              ; preds = %55
  call void asm sideeffect "", "n"(i32 5) #5
  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

define hidden swiftcc { i64, i64 } @"$s7llvm_O310getIntPairSi_SityF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_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 !6

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 !6

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 !6

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 !6

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 !6

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 !6

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 !6

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 !6

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

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

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

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

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

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

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

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

define hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$s7llvm_O37getInts5countSaySiGSi_tF"(i64 %0) local_unnamed_addr #0 {
entry:
  %1 = icmp slt i64 %0, -2147483648
  br i1 %1, label %69, label %2, !prof !6

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

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 !6

8:                                                ; preds = %4
  %9 = extractvalue { i32, i1 } %6, 0
  %10 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_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 !6

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 !6

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 !6

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 !7
  %._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 !6

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 !6

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 !6

.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) #5
  tail call void @llvm.trap()
  unreachable

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

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

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

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

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

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

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

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

define hidden swiftcc void @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfC"(%T7llvm_O311FenwickTreeVySiG* noalias nocapture writeonly sret(%T7llvm_O311FenwickTreeVySiG) %0, i64 %1) local_unnamed_addr #0 {
entry:
  %2 = icmp slt i64 %1, 0
  br i1 %2, label %9, label %3, !prof !6

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

.thread.loopexit:                                 ; preds = %3
  %4 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa28_allocateBufferUninitialized15minimumCapacitys016_ContiguousArrayB0VyxGSi_tFZ"(i64 %1, %swift.type* nonnull @"$sSiN")
  %._storage.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %4, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %1, i64* %._storage.count._value, align 8
  %5 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %4, i64 1
  %6 = bitcast %Ts28__ContiguousArrayStorageBaseC* %5 to i8*
  %7 = shl nuw i64 %1, 3
  tail call void @llvm.memset.p0i8.i64(i8* align 8 %6, i8 0, i64 %7, i1 false)
  br label %.thread

.thread:                                          ; preds = %.thread.loopexit, %3
  %8 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %3 ], [ %4, %.thread.loopexit ]
  %.count._value = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 0, i32 0
  store i64 %1, i64* %.count._value, align 8
  %.zeroValue._value = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 1, i32 0
  store i64 0, i64* %.zeroValue._value, align 8
  %.tree._buffer._storage = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 2, i32 0, i32 0
  store %Ts28__ContiguousArrayStorageBaseC* %8, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  %.combine.fn = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 3, i32 0
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu_" to i8*), i8** %.combine.fn, align 8
  %.combine.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 3, i32 1
  store %swift.refcounted* null, %swift.refcounted** %.combine.data, align 8
  %.inverse.fn = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 4, i32 0
  store i8* bitcast (void (%TSi*, %TSi*, %TSi*)* @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu0_" to i8*), i8** %.inverse.fn, align 8
  %.inverse.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %0, i64 0, i32 4, i32 1
  store %swift.refcounted* null, %swift.refcounted** %.inverse.data, align 8
  ret void

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

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

define linkonce_odr hidden swiftcc void @"$s7llvm_O311FenwickTreeV6update2at6addingySi_xtFSi_Tg5"(i64 %0, i64 %1, %T7llvm_O311FenwickTreeVySiG* 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_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 3
  %.tree9._buffer._storage = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %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_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %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 !7
  %.not20 = icmp eq i64 %17, 0
  br i1 %.not20, label %71, label %18, !prof !6

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) #28
  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) #5
  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) #28
  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 !7
  %.not21 = icmp eq i64 %28, 0
  br i1 %.not21, label %72, label %29, !prof !6

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_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %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_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %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) #28
  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 !6

51:                                               ; preds = %48
  %52 = load i64, i64* %._storage.count._value, align 8, !range !7
  %.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) #28
  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) #5
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %45)
  %56 = load i64, i64* %._storage.count._value, align 8, !range !7
  %.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 !6

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) #5
  tail call void @llvm.trap()
  unreachable

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

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

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

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

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

define hidden swiftcc void @"$s7llvm_O311FenwickTreeV6update2at6addingySi_xtF"(i64 %0, %swift.opaque* noalias nocapture %1, %swift.type* nocapture readonly %"FenwickTree<Element>", %T7llvm_O311FenwickTreeV* 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_O311FenwickTreeV* %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) #28
  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) #5
  call void @swift_release(%swift.refcounted* %24) #5
  %35 = call swiftcc %swift.metadata_response @"$sSaMa"(i64 0, %swift.type* nonnull %Element) #30
  %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 !7
  %.not.i.not = icmp eq i64 %38, 0
  br i1 %.not.i.not, label %39, label %"$sSa24_checkSubscript_mutatingyySiF.exit", !prof !6

39:                                               ; preds = %20
  call void asm sideeffect "", "n"(i32 1) #5
  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) #5
  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_O311FenwickTreeV, %T7llvm_O311FenwickTreeV* %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 = %98, %52
  %69 = phi i64 [ %0, %52 ], [ %99, %98 ]
  %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) #28
  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) #5
  call void @swift_release(%swift.refcounted* %71) #5
  %75 = call swiftcc %swift.metadata_response @"$sSaMa"(i64 0, %swift.type* %Element) #30
  %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
  %78 = icmp slt i64 %69, 0
  br i1 %78, label %81, label %79, !prof !6

79:                                               ; preds = %68
  %._storage.count._value.i10 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %77, i64 0, i32 1, i32 0, i32 0, i32 0
  %80 = load i64, i64* %._storage.count._value.i10, align 8, !range !7
  %.not.i11 = icmp ugt i64 %80, %69
  br i1 %.not.i11, label %"$sSa24_checkSubscript_mutatingyySiF.exit12", label %82, !prof !8

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

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

"$sSa24_checkSubscript_mutatingyySiF.exit12":     ; preds = %79
  %flags = load i32, i32* %63, align 8, !invariant.load !9
  %83 = and i32 %flags, 255
  %flags.alignmentMask = zext i32 %83 to i64
  %84 = add nuw nsw i64 %flags.alignmentMask, 32
  %85 = xor i64 %flags.alignmentMask, -1
  %86 = and i64 %84, %85
  %87 = bitcast %Ts28__ContiguousArrayStorageBaseC* %77 to i8*
  %88 = getelementptr inbounds i8, i8* %87, i64 %86
  %stride = load i64, i64* %65, align 8, !invariant.load !9
  %89 = mul nsw i64 %stride, %69
  %90 = getelementptr inbounds i8, i8* %88, i64 %89
  %91 = bitcast i8* %90 to %swift.opaque*
  %92 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %67, align 8, !invariant.load !9
  %93 = call %swift.opaque* %92(%swift.opaque* noalias %91, %swift.opaque* noalias nonnull %12, %swift.type* %Element) #5
  %94 = sub nsw i64 0, %69
  %95 = and i64 %69, %94
  %96 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %69, i64 %95)
  %97 = extractvalue { i64, i1 } %96, 1
  br i1 %97, label %102, label %98, !prof !6

98:                                               ; preds = %"$sSa24_checkSubscript_mutatingyySiF.exit12"
  %99 = extractvalue { i64, i1 } %96, 0
  %100 = load i64, i64* %.count._value, align 8
  %101 = icmp slt i64 %99, %100
  br i1 %101, label %68, label %.loopexit

.loopexit:                                        ; preds = %98, %"$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

102:                                              ; preds = %"$sSa24_checkSubscript_mutatingyySiF.exit12"
  call void asm sideeffect "", "n"(i32 1) #5
  call void @llvm.trap()
  unreachable
}

define hidden swiftcc { i64, i64, i64 } @"$s7llvm_O313getIntTripletSi_S2ityF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 72)
  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 %123, label %22, !prof !6

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 %112, label %27, !prof !6

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 %113, label %32, !prof !6

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 %114, label %11, !prof !6

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 %60

47:                                               ; preds = %68, %52, %37
  %48 = phi i64 [ %39, %37 ], [ %39, %52 ], [ %71, %68 ]
  %49 = phi i1 [ %40, %37 ], [ true, %52 ], [ false, %68 ]
  %50 = phi i1 [ true, %37 ], [ %41, %52 ], [ %41, %68 ]
  %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 %122, label %58, !prof !6

58:                                               ; preds = %53, %54
  %59 = phi i64 [ %56, %54 ], [ %39, %53 ]
  br label %73

60:                                               ; preds = %44
  %.3 = select i1 %40, i64 0, i64 %39
  %61 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.3, i64 10)
  %62 = extractvalue { i64, i1 } %61, 1
  br i1 %62, label %115, label %63, !prof !6

63:                                               ; preds = %60
  %64 = extractvalue { i64, i1 } %61, 0
  %65 = zext i8 %38 to i64
  %66 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %64, i64 %65)
  %67 = extractvalue { i64, i1 } %66, 1
  br i1 %67, label %116, label %68, !prof !6

68:                                               ; preds = %63
  %69 = extractvalue { i64, i1 } %66, 0
  %70 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %69, i64 -48)
  %71 = extractvalue { i64, i1 } %70, 0
  %72 = extractvalue { i64, i1 } %70, 1
  br i1 %72, label %117, label %47, !prof !6

73:                                               ; preds = %83, %58
  %74 = phi i8 [ %38, %58 ], [ %.pre70, %83 ]
  %75 = phi i64 [ 0, %58 ], [ %84, %83 ]
  %76 = phi i1 [ true, %58 ], [ %85, %83 ]
  %77 = phi i1 [ false, %58 ], [ %86, %83 ]
  %78 = phi i8* [ %42, %58 ], [ %87, %83 ]
  %79 = icmp eq i8 %74, 45
  br i1 %79, label %83, label %80

80:                                               ; preds = %73
  %81 = add i8 %74, -58
  %82 = icmp ult i8 %81, -10
  br i1 %82, label %88, label %99

83:                                               ; preds = %107, %88, %73
  %84 = phi i64 [ %75, %73 ], [ %75, %88 ], [ %110, %107 ]
  %85 = phi i1 [ %76, %73 ], [ true, %88 ], [ false, %107 ]
  %86 = phi i1 [ true, %73 ], [ %77, %88 ], [ %77, %107 ]
  %87 = getelementptr inbounds i8, i8* %78, i64 1
  %.pre70 = load i8, i8* %87, align 1
  br label %73

88:                                               ; preds = %80
  br i1 %76, label %83, label %89

89:                                               ; preds = %88
  br i1 %77, label %90, label %94

90:                                               ; preds = %89
  %91 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %75)
  %92 = extractvalue { i64, i1 } %91, 0
  %93 = extractvalue { i64, i1 } %91, 1
  br i1 %93, label %121, label %94, !prof !6

94:                                               ; preds = %89, %90
  %95 = phi i64 [ %92, %90 ], [ %75, %89 ]
  %96 = insertvalue { i64, i64, i64 } undef, i64 %23, 0
  %97 = insertvalue { i64, i64, i64 } %96, i64 %59, 1
  %98 = insertvalue { i64, i64, i64 } %97, i64 %95, 2
  ret { i64, i64, i64 } %98

99:                                               ; preds = %80
  %.4 = select i1 %76, i64 0, i64 %75
  %100 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.4, i64 10)
  %101 = extractvalue { i64, i1 } %100, 1
  br i1 %101, label %118, label %102, !prof !6

102:                                              ; preds = %99
  %103 = extractvalue { i64, i1 } %100, 0
  %104 = zext i8 %74 to i64
  %105 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %103, i64 %104)
  %106 = extractvalue { i64, i1 } %105, 1
  br i1 %106, label %119, label %107, !prof !6

107:                                              ; preds = %102
  %108 = extractvalue { i64, i1 } %105, 0
  %109 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %108, i64 -48)
  %110 = extractvalue { i64, i1 } %109, 0
  %111 = extractvalue { i64, i1 } %109, 1
  br i1 %111, label %120, label %83, !prof !6

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

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

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

115:                                              ; preds = %60
  tail call void asm sideeffect "", "n"(i32 3) #5
  tail call void @llvm.trap()
  unreachable

116:                                              ; preds = %63
  tail call void asm sideeffect "", "n"(i32 4) #5
  tail call void @llvm.trap()
  unreachable

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

118:                                              ; preds = %99
  tail call void asm sideeffect "", "n"(i32 6) #5
  tail call void @llvm.trap()
  unreachable

119:                                              ; preds = %102
  tail call void asm sideeffect "", "n"(i32 7) #5
  tail call void @llvm.trap()
  unreachable

120:                                              ; preds = %107
  tail call void asm sideeffect "", "n"(i32 8) #5
  tail call void @llvm.trap()
  unreachable

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

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

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

define linkonce_odr hidden swiftcc i64 @"$s7llvm_O311FenwickTreeV5query5rangexSnySiG_tFSi_Tg5"(i64 %0, i64 %1, %T7llvm_O311FenwickTreeVySiG* noalias 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 = alloca %TSi, align 8
  %9 = alloca %TSi, align 8
  %10 = bitcast %TSi* %3 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %10)
  %.zeroValue._value = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 1, i32 0
  %11 = load i64, i64* %.zeroValue._value, align 8
  %.sroa.0.0..sroa_idx = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 2, i32 0, i32 0
  %.sroa.0.0.copyload = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.sroa.0.0..sroa_idx, align 8
  %.combine.fn = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 3, i32 0
  %12 = load i8*, i8** %.combine.fn, align 8
  %.combine.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 3, i32 1
  %13 = load %swift.refcounted*, %swift.refcounted** %.combine.data, align 8
  %14 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %1, i64 -1)
  %15 = extractvalue { i64, i1 } %14, 0
  %16 = extractvalue { i64, i1 } %14, 1
  br i1 %16, label %73, label %17, !prof !6

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

21:                                               ; preds = %17
  %._value = getelementptr inbounds %TSi, %TSi* %3, i64 0, i32 0
  store i64 %11, i64* %._value, align 8
  %22 = icmp slt i64 %19, 0
  br i1 %22, label %23, label %33

23:                                               ; preds = %21
  %24 = bitcast %TSi* %8 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %24)
  %25 = bitcast %TSi* %9 to i8*
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %25)
  %._storage16.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 0, i32 1, i32 0, i32 0, i32 0
  %26 = load i64, i64* %._storage16.count._value, align 8, !range !7
  %.not43 = icmp eq i64 %26, 0
  br i1 %.not43, label %77, label %27, !prof !6

27:                                               ; preds = %23
  %28 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 1
  %tailaddr17._value = bitcast %Ts28__ContiguousArrayStorageBaseC* %28 to i64*
  %29 = load i64, i64* %tailaddr17._value, align 8
  %._value18 = getelementptr inbounds %TSi, %TSi* %9, i64 0, i32 0
  store i64 %29, i64* %._value18, align 8
  %30 = bitcast i8* %12 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*
  call swiftcc void %30(%TSi* noalias nocapture nonnull sret(%TSi) %8, %TSi* noalias nocapture nonnull dereferenceable(8) %3, %TSi* noalias nocapture nonnull dereferenceable(8) %9, %swift.refcounted* swiftself %13)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %25)
  %._value19 = getelementptr inbounds %TSi, %TSi* %8, i64 0, i32 0
  %31 = load i64, i64* %._value19, align 8
  store i64 %31, i64* %._value, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %24)
  %32 = icmp sgt i64 %15, 0
  br i1 %32, label %._crit_edge, label %35

33:                                               ; preds = %21
  %34 = icmp slt i64 %19, %15
  br i1 %34, label %._crit_edge, label %.loopexit44

35:                                               ; preds = %27
  %36 = icmp slt i64 %15, 0
  br i1 %36, label %54, label %.loopexit

._crit_edge:                                      ; preds = %33, %27
  %37 = phi i64 [ 0, %27 ], [ %19, %33 ]
  %.pre-phi = bitcast i8* %12 to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*
  %38 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 1
  %tailaddr8 = bitcast %Ts28__ContiguousArrayStorageBaseC* %38 to %TSi*
  %._storage9.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 0, i32 1, i32 0, i32 0, i32 0
  %39 = load i64, i64* %._storage9.count._value, align 8, !range !7
  %40 = bitcast %TSi* %6 to i8*
  %41 = bitcast %TSi* %7 to i8*
  %._value11 = getelementptr inbounds %TSi, %TSi* %7, i64 0, i32 0
  %._value12 = getelementptr inbounds %TSi, %TSi* %6, i64 0, i32 0
  br label %42

42:                                               ; preds = %44, %._crit_edge
  %43 = phi i64 [ %15, %._crit_edge ], [ %48, %44 ]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %40)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %41)
  %.not42 = icmp ult i64 %43, %39
  br i1 %.not42, label %44, label %76, !prof !8

44:                                               ; preds = %42
  %._value10 = getelementptr inbounds %TSi, %TSi* %tailaddr8, i64 %43, i32 0
  %45 = load i64, i64* %._value10, align 8
  store i64 %45, i64* %._value11, align 8
  call swiftcc void %.pre-phi(%TSi* noalias nocapture nonnull sret(%TSi) %6, %TSi* noalias nocapture nonnull dereferenceable(8) %3, %TSi* noalias nocapture nonnull dereferenceable(8) %7, %swift.refcounted* swiftself %13)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %41)
  %46 = load i64, i64* %._value12, align 8
  store i64 %46, i64* %._value, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %40)
  %47 = add nsw i64 %43, -1
  %48 = and i64 %47, %43
  %49 = icmp slt i64 %37, %48
  br i1 %49, label %42, label %.loopexit44

.loopexit44:                                      ; preds = %44, %33
  %50 = phi i64 [ %15, %33 ], [ %48, %44 ]
  %51 = phi i64 [ %19, %33 ], [ %37, %44 ]
  %52 = phi i64 [ %11, %33 ], [ %46, %44 ]
  %53 = icmp slt i64 %50, %51
  br i1 %53, label %54, label %.loopexit

54:                                               ; preds = %35, %.loopexit44
  %55 = phi i64 [ %50, %.loopexit44 ], [ %15, %35 ]
  %56 = phi i64 [ %51, %.loopexit44 ], [ 0, %35 ]
  %.inverse = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 4
  %57 = bitcast %swift.function* %.inverse to void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)**
  %58 = load void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)*, void (%TSi*, %TSi*, %TSi*, %swift.refcounted*)** %57, align 8
  %.inverse.data = getelementptr inbounds %T7llvm_O311FenwickTreeVySiG, %T7llvm_O311FenwickTreeVySiG* %2, i64 0, i32 4, i32 1
  %59 = load %swift.refcounted*, %swift.refcounted** %.inverse.data, align 8
  %60 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %60 to %TSi*
  %._storage1.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %.sroa.0.0.copyload, i64 0, i32 1, i32 0, i32 0, i32 0
  %61 = load i64, i64* %._storage1.count._value, align 8, !range !7
  %62 = bitcast %TSi* %4 to i8*
  %63 = bitcast %TSi* %5 to i8*
  %._value3 = getelementptr inbounds %TSi, %TSi* %5, i64 0, i32 0
  %._value4 = getelementptr inbounds %TSi, %TSi* %4, i64 0, i32 0
  br label %64

64:                                               ; preds = %66, %54
  %65 = phi i64 [ %56, %54 ], [ %70, %66 ]
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %62)
  call void @llvm.lifetime.start.p0i8(i64 8, i8* nonnull %63)
  %.not = icmp slt i64 %65, %61
  br i1 %.not, label %66, label %75, !prof !8

66:                                               ; preds = %64
  %._value2 = getelementptr inbounds %TSi, %TSi* %tailaddr, i64 %65, i32 0
  %67 = load i64, i64* %._value2, align 8
  store i64 %67, i64* %._value3, align 8
  call swiftcc void %58(%TSi* noalias nocapture nonnull sret(%TSi) %4, %TSi* noalias nocapture nonnull dereferenceable(8) %3, %TSi* noalias nocapture nonnull dereferenceable(8) %5, %swift.refcounted* swiftself %59)
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %63)
  %68 = load i64, i64* %._value4, align 8
  store i64 %68, i64* %._value, align 8
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %62)
  %69 = add nsw i64 %65, -1
  %70 = and i64 %69, %65
  %71 = icmp slt i64 %55, %70
  br i1 %71, label %64, label %.loopexit

.loopexit:                                        ; preds = %66, %35, %.loopexit44
  %72 = phi i64 [ %52, %.loopexit44 ], [ %31, %35 ], [ %68, %66 ]
  call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %10)
  ret i64 %72

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

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

75:                                               ; preds = %64
  tail call void asm sideeffect "", "n"(i32 2) #5
  tail call void @llvm.trap()
  unreachable

76:                                               ; preds = %42
  tail call void asm sideeffect "", "n"(i32 4) #5
  tail call void @llvm.trap()
  unreachable

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

define hidden swiftcc void @"$s7llvm_O311FenwickTreeV5query5rangexSnySiG_tF"(%swift.opaque* noalias nocapture sret(%swift.opaque) %0, i64 %1, i64 %2, %swift.type* nocapture readonly %"FenwickTree<Element>", %T7llvm_O311FenwickTreeV* 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 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %2, i64 -1)
  %15 = extractvalue { i64, i1 } %14, 0
  %16 = extractvalue { i64, i1 } %14, 1
  br i1 %16, label %119, label %17, !prof !6

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

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

33:                                               ; preds = %21
  %34 = getelementptr inbounds i32, i32* %22, i64 9
  %35 = load i32, i32* %34, align 8
  %36 = sext i32 %35 to i64
  %37 = getelementptr inbounds i8, i8* %25, i64 %36
  %38 = bitcast i8* %37 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %39 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %38, align 8
  %.combine4.data = getelementptr inbounds i8, i8* %37, i64 8
  %40 = bitcast i8* %.combine4.data to %swift.refcounted**
  %41 = load %swift.refcounted*, %swift.refcounted** %40, align 8
  %42 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %43 = bitcast %swift.type* %42 to i32*
  %44 = load i32, i32* %43, align 8
  %45 = sext i32 %44 to i64
  %46 = getelementptr inbounds i8, i8* %25, i64 %45
  %.tree5._buffer._storage = bitcast i8* %46 to %Ts28__ContiguousArrayStorageBaseC**
  %47 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree5._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 0, %Ts28__ContiguousArrayStorageBaseC* %47, %swift.type* nonnull %Element)
  call swiftcc void %39(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %41)
  %48 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %49 = bitcast i8** %48 to void (%swift.opaque*, %swift.type*)**
  %50 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %49, align 8, !invariant.load !9
  call void %50(%swift.opaque* noalias nonnull %11, %swift.type* nonnull %Element) #5
  call void %50(%swift.opaque* noalias %0, %swift.type* nonnull %Element) #5
  %51 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %52 = bitcast i8** %51 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %53 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %52, align 8, !invariant.load !9
  %54 = call %swift.opaque* %53(%swift.opaque* noalias %0, %swift.opaque* noalias nonnull %13, %swift.type* nonnull %Element) #5
  %55 = icmp sgt i64 %15, 0
  br i1 %55, label %._crit_edge, label %58

56:                                               ; preds = %21
  %57 = icmp slt i64 %19, %15
  br i1 %57, label %._crit_edge, label %.loopexit14

58:                                               ; preds = %33
  %59 = icmp slt i64 %15, 0
  br i1 %59, label %.loopexit14._crit_edge, label %.loopexit

._crit_edge:                                      ; preds = %56, %33
  %60 = phi i64 [ 0, %33 ], [ %19, %56 ]
  %61 = getelementptr inbounds i32, i32* %22, i64 9
  %62 = load i32, i32* %61, align 8
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds i8, i8* %25, i64 %63
  %65 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %66 = bitcast %swift.type* %65 to i32*
  %67 = load i32, i32* %66, align 8
  %68 = sext i32 %67 to i64
  %69 = getelementptr inbounds i8, i8* %25, i64 %68
  %70 = bitcast i8* %64 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %.combine.data = getelementptr inbounds i8, i8* %64, i64 8
  %71 = bitcast i8* %.combine.data to %swift.refcounted**
  %.tree1._buffer._storage = bitcast i8* %69 to %Ts28__ContiguousArrayStorageBaseC**
  %72 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %73 = bitcast i8** %72 to void (%swift.opaque*, %swift.type*)**
  %74 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %75 = bitcast i8** %74 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  br label %76

76:                                               ; preds = %76, %._crit_edge
  %77 = phi i64 [ %15, %._crit_edge ], [ %85, %76 ]
  %78 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %70, align 8
  %79 = load %swift.refcounted*, %swift.refcounted** %71, align 8
  %80 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree1._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 %77, %Ts28__ContiguousArrayStorageBaseC* %80, %swift.type* %Element)
  call swiftcc void %78(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %79)
  %81 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %73, align 8, !invariant.load !9
  call void %81(%swift.opaque* noalias nonnull %11, %swift.type* %Element) #5
  call void %81(%swift.opaque* noalias %0, %swift.type* %Element) #5
  %82 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %75, align 8, !invariant.load !9
  %83 = call %swift.opaque* %82(%swift.opaque* noalias %0, %swift.opaque* noalias nonnull %13, %swift.type* %Element) #5
  %84 = add nsw i64 %77, -1
  %85 = and i64 %84, %77
  %86 = icmp slt i64 %60, %85
  br i1 %86, label %76, label %.loopexit14

.loopexit14:                                      ; preds = %76, %56
  %87 = phi i64 [ %15, %56 ], [ %85, %76 ]
  %88 = phi i64 [ %19, %56 ], [ %60, %76 ]
  %89 = icmp slt i64 %87, %88
  br i1 %89, label %.loopexit14._crit_edge, label %.loopexit

.loopexit14._crit_edge:                           ; preds = %.loopexit14, %58
  %90 = phi i64 [ %15, %58 ], [ %87, %.loopexit14 ]
  %91 = phi i64 [ 0, %58 ], [ %88, %.loopexit14 ]
  %92 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 5
  %93 = bitcast %swift.type* %92 to i32*
  %94 = load i32, i32* %93, align 8
  %95 = sext i32 %94 to i64
  %96 = getelementptr inbounds i8, i8* %25, i64 %95
  %97 = getelementptr inbounds %swift.type, %swift.type* %"FenwickTree<Element>", i64 4
  %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* %25, i64 %100
  %102 = bitcast i8* %96 to void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)**
  %.inverse.data = getelementptr inbounds i8, i8* %96, i64 8
  %103 = bitcast i8* %.inverse.data to %swift.refcounted**
  %.tree._buffer._storage = bitcast i8* %101 to %Ts28__ContiguousArrayStorageBaseC**
  %104 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 1
  %105 = bitcast i8** %104 to void (%swift.opaque*, %swift.type*)**
  %106 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %107 = bitcast i8** %106 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  br label %108

108:                                              ; preds = %108, %.loopexit14._crit_edge
  %109 = phi i64 [ %91, %.loopexit14._crit_edge ], [ %117, %108 ]
  %110 = load void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)*, void (%swift.opaque*, %swift.opaque*, %swift.opaque*, %swift.refcounted*)** %102, align 8
  %111 = load %swift.refcounted*, %swift.refcounted** %103, align 8
  %112 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  call swiftcc void @"$sSayxSicig"(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %11, i64 %109, %Ts28__ContiguousArrayStorageBaseC* %112, %swift.type* %Element)
  call swiftcc void %110(%swift.opaque* noalias nocapture nonnull sret(%swift.opaque) %13, %swift.opaque* noalias nocapture %0, %swift.opaque* noalias nocapture nonnull %11, %swift.refcounted* swiftself %111)
  %113 = load void (%swift.opaque*, %swift.type*)*, void (%swift.opaque*, %swift.type*)** %105, align 8, !invariant.load !9
  call void %113(%swift.opaque* noalias nonnull %11, %swift.type* %Element) #5
  call void %113(%swift.opaque* noalias %0, %swift.type* %Element) #5
  %114 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %107, align 8, !invariant.load !9
  %115 = call %swift.opaque* %114(%swift.opaque* noalias %0, %swift.opaque* noalias nonnull %13, %swift.type* %Element) #5
  %116 = add nsw i64 %109, -1
  %117 = and i64 %116, %109
  %118 = icmp slt i64 %90, %117
  br i1 %118, label %108, label %.loopexit

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

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

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

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

define hidden swiftcc void @"$s7llvm_O311FenwickTreeV5count9zeroValue5addBy06removeI0ACyxGSi_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 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCTf4gnn_n"(%swift.opaque* noalias nocapture %2, i64 %1, %swift.type* %Element)
  %8 = tail call swiftcc %swift.metadata_response @"$s7llvm_O311FenwickTreeVMa"(i64 0, %swift.type* %Element) #30
  %9 = extractvalue %swift.metadata_response %8, 0
  %10 = bitcast %swift.type* %9 to i32*
  %11 = getelementptr inbounds %swift.type, %swift.type* %9, i64 4
  %12 = bitcast %swift.type* %11 to i32*
  %13 = load i32, i32* %12, align 8
  %14 = bitcast %swift.opaque* %0 to i8*
  %15 = sext i32 %13 to i64
  %16 = getelementptr inbounds i8, i8* %14, i64 %15
  %.tree._buffer._storage = bitcast i8* %16 to %Ts28__ContiguousArrayStorageBaseC**
  store %Ts28__ContiguousArrayStorageBaseC* %7, %Ts28__ContiguousArrayStorageBaseC** %.tree._buffer._storage, align 8
  %.count._value = bitcast %swift.opaque* %0 to i64*
  store i64 %1, i64* %.count._value, align 8
  %17 = getelementptr inbounds i32, i32* %10, i64 7
  %18 = load i32, i32* %17, align 8
  %19 = sext i32 %18 to i64
  %20 = getelementptr inbounds i8, i8* %14, i64 %19
  %.zeroValue = bitcast i8* %20 to %swift.opaque*
  %21 = getelementptr inbounds %swift.type, %swift.type* %Element, i64 -1
  %22 = bitcast %swift.type* %21 to i8***
  %Element.valueWitnesses = load i8**, i8*** %22, align 8, !invariant.load !9, !dereferenceable !10
  %23 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 4
  %24 = bitcast i8** %23 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %25 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %24, align 8, !invariant.load !9
  %26 = tail call %swift.opaque* %25(%swift.opaque* noalias %.zeroValue, %swift.opaque* noalias %2, %swift.type* %Element) #5
  %27 = getelementptr inbounds i32, i32* %10, i64 9
  %28 = load i32, i32* %27, align 8
  %29 = sext i32 %28 to i64
  %30 = getelementptr inbounds i8, i8* %14, i64 %29
  %.combine.fn = bitcast i8* %30 to i8**
  store i8* %3, i8** %.combine.fn, align 8
  %.combine.data = getelementptr inbounds i8, i8* %30, i64 8
  %31 = bitcast i8* %.combine.data to %swift.refcounted**
  store %swift.refcounted* %4, %swift.refcounted** %31, align 8
  %32 = getelementptr inbounds %swift.type, %swift.type* %9, i64 5
  %33 = bitcast %swift.type* %32 to i32*
  %34 = load i32, i32* %33, align 8
  %35 = sext i32 %34 to i64
  %36 = getelementptr inbounds i8, i8* %14, i64 %35
  %.inverse.fn = bitcast i8* %36 to i8**
  store i8* %5, i8** %.inverse.fn, align 8
  %.inverse.data = getelementptr inbounds i8, i8* %36, i64 8
  %37 = bitcast i8* %.inverse.data to %swift.refcounted**
  store %swift.refcounted* %6, %swift.refcounted** %37, align 8
  ret void
}

define internal swiftcc void @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu_"(%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 !6

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) #5
  tail call void @llvm.trap()
  unreachable
}

define internal swiftcc void @"$s7llvm_O311FenwickTreeVAASiRszlE5countACySiGSi_tcfcS2i_Sitcfu0_"(%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 !6

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) #5
  tail call void @llvm.trap()
  unreachable
}

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

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

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

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

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

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

; 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) #6

; Function Attrs: noinline nounwind
define linkonce_odr hidden %TSa* @"$sSaySiGWOr"(%TSa* %0) local_unnamed_addr #7 {
entry:
  %1 = bitcast %TSa* %0 to %swift.refcounted**
  %2 = load %swift.refcounted*, %swift.refcounted** %1, align 8
  %3 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %2) #28
  ret %TSa* %0
}

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

; Function Attrs: noinline nounwind
define linkonce_odr hidden %TSa* @"$sSaySiGWOs"(%TSa* %0) local_unnamed_addr #7 {
entry:
  %._buffer._storage = getelementptr inbounds %TSa, %TSa* %0, i64 0, i32 0, i32 0
  %1 = load %Ts28__ContiguousArrayStorageBaseC*, %Ts28__ContiguousArrayStorageBaseC** %._buffer._storage, align 8
  %2 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %1, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %2) #5
  ret %TSa* %0
}

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

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

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
define internal void @"$s7llvm_O32IOV5INPUT_WZ"(i8* nocapture readnone %0) #9 {
entry:
  %1 = load i64, i64* bitcast (%struct._IO_FILE** @stdin to i64*), align 8
  store i64 %1, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" to i64*), align 8
  ret void
}

; Function Attrs: nounwind
define hidden swiftcc nonnull i8* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvau"() local_unnamed_addr #10 {
entry:
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV5INPUT_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV5INPUT_WZ" to i8*), i8* undef) #5
  ret i8* getelementptr inbounds (%TSpySo8_IO_FILEVGSg, %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ", i64 0, i32 0, i64 0)
}

; Function Attrs: nounwind
define hidden swiftcc i64 @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvgZ"() local_unnamed_addr #10 {
entry:
  %access-scratch = alloca [24 x i8], align 8
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV5INPUT_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV5INPUT_WZ" to i8*), i8* undef) #5
  %0 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %0)
  call void @swift_beginAccess(i8* nonnull getelementptr inbounds (%TSpySo8_IO_FILEVGSg, %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch, i64 0, i8* null) #5
  %1 = load i64, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" to i64*), align 8
  ret i64 %1
}

; Function Attrs: nounwind
define hidden swiftcc void @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvsZ"(i64 %0) local_unnamed_addr #10 {
entry:
  %access-scratch = alloca [24 x i8], align 8
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV5INPUT_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV5INPUT_WZ" to i8*), i8* undef) #5
  %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 getelementptr inbounds (%TSpySo8_IO_FILEVGSg, %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch, i64 1, i8* null) #5
  store i64 %0, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" to i64*), align 8
  ret void
}

; Function Attrs: noinline nounwind
define hidden swiftcc { i8*, %TSpySo8_IO_FILEVGSg* } @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvMZ"(i8* noalias dereferenceable(32) %0) local_unnamed_addr #7 {
coro.return:
  %access-scratch = bitcast i8* %0 to [24 x i8]*
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV5INPUT_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV5INPUT_WZ" to i8*), i8* undef) #5
  tail call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %0)
  tail call void @swift_beginAccess(i8* nonnull getelementptr inbounds (%TSpySo8_IO_FILEVGSg, %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch, i64 33, i8* null) #5
  ret { i8*, %TSpySo8_IO_FILEVGSg* } { i8* bitcast (void (i8*, i1)* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvMZ.resume.0" to i8*), %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" }
}

; Function Attrs: nounwind
define internal swiftcc void @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvMZ.resume.0"(i8* noalias nonnull align 8 dereferenceable(32) %0, i1 %1) #10 {
entryresume.0:
  %access-scratch = bitcast i8* %0 to [24 x i8]*
  tail call void @swift_endAccess([24 x i8]* nonnull %access-scratch) #5
  tail call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %0)
  ret void
}

; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn writeonly
define internal void @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_WZ"(i8* nocapture readnone %0) #11 {
entry:
  store i64 0, i64* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LLSpys4Int8VGSgvpZ.0", align 8
  ret void
}

; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
define hidden swiftcc void @"$s7llvm_O32IOVACycfC"() local_unnamed_addr #12 {
entry:
  ret void
}

define internal swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 %0) unnamed_addr #0 {
entry:
  %access-scratch = alloca [24 x i8], align 8
  %1 = load i32, i32* @"$s7llvm_O32IOV14bufferCapacity33_73E641EE209B6240D9CA5E4E565FCA33LLs5Int32VvpZ.0", align 4
  %2 = icmp slt i32 %1, %0
  br i1 %2, label %3, label %12

3:                                                ; preds = %entry
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_WZ" to i8*), i8* undef) #5
  %4 = load i64, i64* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LLSpys4Int8VGSgvpZ.0", align 8
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %8, label %6

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

8:                                                ; preds = %3, %6
  %9 = sext i32 %0 to i64
  %10 = tail call noalias i8* @swift_slowAlloc(i64 %9, i64 -1) #5
  %11 = ptrtoint i8* %10 to i64
  store i64 %11, i64* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LLSpys4Int8VGSgvpZ.0", align 8
  store i32 %0, i32* @"$s7llvm_O32IOV14bufferCapacity33_73E641EE209B6240D9CA5E4E565FCA33LLs5Int32VvpZ.0", align 4
  br label %12

12:                                               ; preds = %entry, %8
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LL_WZ" to i8*), i8* undef) #5
  %13 = load i64, i64* @"$s7llvm_O32IOV6buffer33_73E641EE209B6240D9CA5E4E565FCA33LLSpys4Int8VGSgvpZ.0", align 8
  %14 = icmp eq i64 %13, 0
  br i1 %14, label %23, label %15

15:                                               ; preds = %12
  tail call void @swift_once(i64* nonnull @"$s7llvm_O32IOV5INPUT_Wz", i8* nonnull bitcast (void (i8*)* @"$s7llvm_O32IOV5INPUT_WZ" to i8*), i8* undef) #5
  %16 = getelementptr inbounds [24 x i8], [24 x i8]* %access-scratch, i64 0, i64 0
  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %16)
  call void @swift_beginAccess(i8* nonnull getelementptr inbounds (%TSpySo8_IO_FILEVGSg, %TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ", i64 0, i32 0, i64 0), [24 x i8]* nonnull %access-scratch, i64 0, i8* null) #5
  %17 = load i64, i64* bitcast (%TSpySo8_IO_FILEVGSg* @"$s7llvm_O32IOV5INPUTSpySo01_C5_FILEVGSgvpZ" to i64*), align 8
  %18 = inttoptr i64 %13 to i8*
  %19 = inttoptr i64 %17 to %struct._IO_FILE*
  %20 = call i8* @fgets(i8* nonnull %18, i32 %0, %struct._IO_FILE* %19)
  %21 = icmp eq i8* %20, null
  br i1 %21, label %24, label %22

22:                                               ; preds = %15
  ret i8* %20

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

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

define hidden swiftcc { i64, %swift.bridge* } @"$s7llvm_O39getString9maxLengthSSSi_tF"(i64 %0) local_unnamed_addr #0 {
entry:
  %1 = alloca %TSS, align 8
  %2 = bitcast %TSS* %1 to i8*
  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %2)
  %3 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %0, i64 3)
  %4 = extractvalue { i64, i1 } %3, 0
  %5 = extractvalue { i64, i1 } %3, 1
  br i1 %5, label %54, label %6, !prof !6

6:                                                ; preds = %entry
  %7 = icmp slt i64 %4, -2147483648
  br i1 %7, label %55, label %8, !prof !6

8:                                                ; preds = %6
  %9 = icmp sgt i64 %4, 2147483647
  br i1 %9, label %56, label %10, !prof !6

10:                                               ; preds = %8
  %11 = trunc i64 %4 to i32
  %12 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 %11)
  %13 = tail call swiftcc { i64, %swift.bridge* } @"$sSS7cStringSSSPys4Int8VG_tcfC"(i8* %12)
  %14 = extractvalue { i64, %swift.bridge* } %13, 0
  %15 = extractvalue { i64, %swift.bridge* } %13, 1
  %._guts._object._countAndFlagsBits._value = getelementptr inbounds %TSS, %TSS* %1, i64 0, i32 0, i32 0, i32 0, i32 0
  store i64 %14, 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* %15, %swift.bridge** %._guts._object._object, align 8
  %16 = tail call %swift.bridge* @swift_bridgeObjectRetain(%swift.bridge* returned %15) #5
  %17 = tail call swiftcc { i64, i64 } @"$sSKsE4last7ElementQzSgvgSS_Tg5"(i64 %14, %swift.bridge* %15)
  tail call void @swift_bridgeObjectRelease(%swift.bridge* %15) #5
  %18 = extractvalue { i64, i64 } %17, 0
  %19 = extractvalue { i64, i64 } %17, 1
  %20 = icmp eq i64 %19, 0
  br i1 %20, label %31, label %21

21:                                               ; preds = %10
  %22 = inttoptr i64 %19 to %swift.bridge*
  %23 = icmp eq i64 %18, 10
  %24 = icmp eq i64 %19, -2233785415175766016
  %or.cond = select i1 %23, i1 %24, i1 false
  br i1 %or.cond, label %25, label %26

25:                                               ; preds = %21
  tail call void @swift_bridgeObjectRelease(%swift.bridge* nonnull %22) #5
  br label %28

26:                                               ; preds = %21
  %27 = tail call swiftcc i1 @"$ss27_stringCompareWithSmolCheck__9expectingSbs11_StringGutsV_ADs01_G16ComparisonResultOtF"(i64 %18, %swift.bridge* nonnull %22, i64 10, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), i8 0)
  tail call void @swift_bridgeObjectRelease(%swift.bridge* nonnull %22) #5
  br i1 %27, label %28, label %31

28:                                               ; preds = %26, %25
  %29 = call swiftcc { i64, %swift.bridge* } @"$sSmsSKRzrlE10removeLast7ElementSTQzyFSS_Tg5"(%TSS* nocapture nonnull swiftself dereferenceable(16) %1)
  %30 = extractvalue { i64, %swift.bridge* } %29, 1
  tail call void @swift_bridgeObjectRelease(%swift.bridge* %30) #5
  %.pre = load i64, i64* %._guts._object._countAndFlagsBits._value, align 8
  %.pre18 = load %swift.bridge*, %swift.bridge** %._guts._object._object, align 8
  br label %31

31:                                               ; preds = %10, %26, %28
  %32 = phi %swift.bridge* [ %15, %10 ], [ %15, %26 ], [ %.pre18, %28 ]
  %33 = phi i64 [ %14, %10 ], [ %14, %26 ], [ %.pre, %28 ]
  %34 = tail call %swift.bridge* @swift_bridgeObjectRetain(%swift.bridge* returned %32) #5
  %35 = tail call swiftcc { i64, i64 } @"$sSKsE4last7ElementQzSgvgSS_Tg5"(i64 %33, %swift.bridge* %32)
  tail call void @swift_bridgeObjectRelease(%swift.bridge* %32) #5
  %36 = extractvalue { i64, i64 } %35, 0
  %37 = extractvalue { i64, i64 } %35, 1
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %49, label %39

39:                                               ; preds = %31
  %40 = inttoptr i64 %37 to %swift.bridge*
  %41 = icmp eq i64 %36, 13
  %42 = icmp eq i64 %37, -2233785415175766016
  %or.cond17 = select i1 %41, i1 %42, i1 false
  br i1 %or.cond17, label %43, label %44

43:                                               ; preds = %39
  tail call void @swift_bridgeObjectRelease(%swift.bridge* nonnull %40) #5
  br label %46

44:                                               ; preds = %39
  %45 = tail call swiftcc i1 @"$ss27_stringCompareWithSmolCheck__9expectingSbs11_StringGutsV_ADs01_G16ComparisonResultOtF"(i64 %36, %swift.bridge* nonnull %40, i64 13, %swift.bridge* nonnull inttoptr (i64 -2233785415175766016 to %swift.bridge*), i8 0)
  tail call void @swift_bridgeObjectRelease(%swift.bridge* nonnull %40) #5
  br i1 %45, label %46, label %49

46:                                               ; preds = %44, %43
  %47 = call swiftcc { i64, %swift.bridge* } @"$sSmsSKRzrlE10removeLast7ElementSTQzyFSS_Tg5"(%TSS* nocapture nonnull swiftself dereferenceable(16) %1)
  %48 = extractvalue { i64, %swift.bridge* } %47, 1
  tail call void @swift_bridgeObjectRelease(%swift.bridge* %48) #5
  %.pre19 = load i64, i64* %._guts._object._countAndFlagsBits._value, align 8
  %.pre20 = load %swift.bridge*, %swift.bridge** %._guts._object._object, align 8
  br label %49

49:                                               ; preds = %31, %44, %46
  %50 = phi %swift.bridge* [ %32, %31 ], [ %32, %44 ], [ %.pre20, %46 ]
  %51 = phi i64 [ %33, %31 ], [ %33, %44 ], [ %.pre19, %46 ]
  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %2)
  %52 = insertvalue { i64, %swift.bridge* } undef, i64 %51, 0
  %53 = insertvalue { i64, %swift.bridge* } %52, %swift.bridge* %50, 1
  ret { i64, %swift.bridge* } %53

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

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

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

define linkonce_odr hidden swiftcc { i64, i64 } @"$sSKsE4last7ElementQzSgvgSS_Tg5"(i64 %0, %swift.bridge* %1) local_unnamed_addr #0 {
entry:
  %2 = ptrtoint %swift.bridge* %1 to i64
  %3 = and i64 %2, 2305843009213693952
  %4 = icmp eq i64 %3, 0
  %5 = lshr i64 %2, 56
  %6 = and i64 %5, 15
  %7 = and i64 %0, 281474976710655
  %8 = select i1 %4, i64 %7, i64 %6
  %9 = icmp eq i64 %8, 0
  br i1 %9, label %22, label %10

10:                                               ; preds = %entry
  %11 = shl nuw i64 %8, 16
  %12 = and i64 %2, 1152921504606846976
  %13 = icmp ne i64 %12, 0
  %14 = and i64 %0, 576460752303423488
  %15 = icmp eq i64 %14, 0
  %or.cond = select i1 %13, i1 %15, i1 false
  %.v = select i1 %or.cond, i64 11, i64 7
  %16 = or i64 %11, %.v
  %17 = tail call swiftcc i64 @"$sSS5index6beforeSS5IndexVAD_tF"(i64 %16, i64 %0, %swift.bridge* %1)
  %18 = tail call swiftcc { i64, %swift.bridge* } @"$sSSySJSS5IndexVcig"(i64 %17, i64 %0, %swift.bridge* %1)
  %19 = extractvalue { i64, %swift.bridge* } %18, 0
  %20 = extractvalue { i64, %swift.bridge* } %18, 1
  %21 = ptrtoint %swift.bridge* %20 to i64
  br label %22

22:                                               ; preds = %entry, %10
  %23 = phi i64 [ %19, %10 ], [ 0, %entry ]
  %24 = phi i64 [ %21, %10 ], [ 0, %entry ]
  %25 = insertvalue { i64, i64 } undef, i64 %23, 0
  %26 = insertvalue { i64, i64 } %25, i64 %24, 1
  ret { i64, i64 } %26
}

define linkonce_odr hidden swiftcc { i64, %swift.bridge* } @"$sSmsSKRzrlE10removeLast7ElementSTQzyFSS_Tg5"(%TSS* nocapture swiftself dereferenceable(16) %0) local_unnamed_addr #0 {
entry:
  %._guts._object._countAndFlagsBits._value = getelementptr inbounds %TSS, %TSS* %0, i64 0, i32 0, i32 0, i32 0, i32 0
  %1 = load i64, i64* %._guts._object._countAndFlagsBits._value, align 8
  %._guts._object._object = getelementptr inbounds %TSS, %TSS* %0, i64 0, i32 0, i32 0, i32 1
  %2 = load %swift.bridge*, %swift.bridge** %._guts._object._object, align 8
  %3 = ptrtoint %swift.bridge* %2 to i64
  %4 = and i64 %3, 2305843009213693952
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %6, label %9

6:                                                ; preds = %entry
  %7 = and i64 %1, 281474976710655
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %24, label %13, !prof !6

9:                                                ; preds = %entry
  %10 = lshr i64 %3, 56
  %11 = and i64 %10, 15
  %12 = icmp eq i64 %11, 0
  br i1 %12, label %23, label %13, !prof !6

13:                                               ; preds = %9, %6
  %14 = phi i64 [ %7, %6 ], [ %11, %9 ]
  %15 = shl nuw i64 %14, 16
  %16 = and i64 %3, 1152921504606846976
  %17 = icmp ne i64 %16, 0
  %18 = and i64 %1, 576460752303423488
  %19 = icmp eq i64 %18, 0
  %or.cond = select i1 %17, i1 %19, i1 false
  %.v = select i1 %or.cond, i64 11, i64 7
  %20 = or i64 %15, %.v
  %21 = tail call swiftcc i64 @"$sSS5index6beforeSS5IndexVAD_tF"(i64 %20, i64 %1, %swift.bridge* %2)
  %22 = tail call swiftcc { i64, %swift.bridge* } @"$sSS6remove2atSJSS5IndexV_tF"(i64 %21, %TSS* nocapture nonnull swiftself dereferenceable(16) %0)
  ret { i64, %swift.bridge* } %22

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

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

define hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$s7llvm_O316getStringAsArray9maxLengthSays5UInt8VGSi_tF"(i64 %0) local_unnamed_addr #0 {
entry:
  %1 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %0, i64 3)
  %2 = extractvalue { i64, i1 } %1, 0
  %3 = extractvalue { i64, i1 } %1, 1
  br i1 %3, label %45, label %4, !prof !6

4:                                                ; preds = %entry
  %5 = icmp slt i64 %2, -2147483648
  br i1 %5, label %46, label %6, !prof !6

6:                                                ; preds = %4
  %7 = icmp sgt i64 %2, 2147483647
  br i1 %7, label %47, label %8, !prof !6

8:                                                ; preds = %6
  %9 = trunc i64 %2 to i32
  %10 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 %9)
  %11 = getelementptr inbounds i8, i8* %10, i64 %0
  %12 = icmp slt i64 %0, 0
  br i1 %12, label %48, label %13, !prof !6

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

15:                                               ; preds = %13
  %16 = load i8, i8* %10, align 1
  %17 = icmp slt i8 %16, 0
  br i1 %17, label %49, label %18, !prof !6

18:                                               ; preds = %15
  switch i8 %16, label %19 [
    i8 0, label %.loopexit
    i8 10, label %.loopexit
    i8 13, label %.loopexit
  ]

19:                                               ; preds = %18
  %20 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5"(i1 false, i64 1, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*))
  %._storage.count._value.phi.trans.insert = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %20, i64 0, i32 1, i32 0, i32 0, i32 0
  %.pre = load i64, i64* %._storage.count._value.phi.trans.insert, align 8, !range !7
  br label %21

21:                                               ; preds = %43, %19
  %22 = phi i64 [ %.pre, %19 ], [ %28, %43 ]
  %.pn = phi i8* [ %10, %19 ], [ %25, %43 ]
  %23 = phi i8 [ %16, %19 ], [ %41, %43 ]
  %24 = phi %Ts28__ContiguousArrayStorageBaseC* [ %20, %19 ], [ %33, %43 ]
  %25 = getelementptr inbounds i8, i8* %.pn, i64 1
  %._storage._capacityAndFlags._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %24, i64 0, i32 1, i32 0, i32 1, i32 0
  %26 = load i64, i64* %._storage._capacityAndFlags._value, align 8
  %27 = lshr i64 %26, 1
  %28 = add nuw nsw i64 %22, 1
  %.not = icmp ugt i64 %27, %22
  br i1 %.not, label %32, label %29, !prof !8

29:                                               ; preds = %21
  %30 = icmp ugt i64 %26, 1
  %31 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5"(i1 %30, i64 %28, i1 true, %Ts28__ContiguousArrayStorageBaseC* nonnull %24)
  br label %32

32:                                               ; preds = %21, %29
  %33 = phi %Ts28__ContiguousArrayStorageBaseC* [ %31, %29 ], [ %24, %21 ]
  %._storage1.count._value = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %33, i64 0, i32 1, i32 0, i32 0, i32 0
  store i64 %28, i64* %._storage1.count._value, align 8
  %34 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %33, i64 1
  %tailaddr = bitcast %Ts28__ContiguousArrayStorageBaseC* %34 to %Ts5UInt8V*
  %._value2 = getelementptr inbounds %Ts5UInt8V, %Ts5UInt8V* %tailaddr, i64 %22, i32 0
  store i8 %23, i8* %._value2, align 1
  %35 = icmp eq i8* %25, %11
  br i1 %35, label %.loopexit, label %36

36:                                               ; preds = %32
  %37 = icmp ult i8* %25, %10
  %38 = icmp uge i8* %25, %11
  %39 = or i1 %37, %38
  br i1 %39, label %50, label %40, !prof !6

40:                                               ; preds = %36
  %41 = load i8, i8* %25, align 1
  %42 = icmp slt i8 %41, 0
  br i1 %42, label %51, label %43, !prof !6

43:                                               ; preds = %40
  switch i8 %41, label %21 [
    i8 0, label %.loopexit
    i8 10, label %.loopexit
    i8 13, label %.loopexit
  ]

.loopexit:                                        ; preds = %32, %43, %43, %43, %18, %18, %18, %13
  %44 = phi %Ts28__ContiguousArrayStorageBaseC* [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %13 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %18 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %18 ], [ bitcast (%struct._SwiftEmptyArrayStorage* @_swiftEmptyArrayStorage to %Ts28__ContiguousArrayStorageBaseC*), %18 ], [ %33, %43 ], [ %33, %43 ], [ %33, %43 ], [ %33, %32 ]
  ret %Ts28__ContiguousArrayStorageBaseC* %44

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

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

47:                                               ; preds = %6
  tail call void asm sideeffect "", "n"(i32 2) #5
  tail call void @llvm.trap()
  unreachable

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

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

50:                                               ; preds = %36
  tail call void asm sideeffect "", "n"(i32 6) #5
  tail call void @llvm.trap()
  unreachable

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

define hidden swiftcc i64 @"$s7llvm_O36getIntSiyF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_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 !6

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 !6

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 !6

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 !6

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

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

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

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

define hidden swiftcc { i64, i64, i64, i64 } @"$s7llvm_O316getIntQuadrupletSi_S3ityF"() local_unnamed_addr #0 {
entry:
  %0 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 96)
  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 %164, label %22, !prof !6

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 %149, label %27, !prof !6

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 %150, label %32, !prof !6

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 %151, label %11, !prof !6

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 %60

47:                                               ; preds = %68, %52, %37
  %48 = phi i64 [ %39, %37 ], [ %39, %52 ], [ %71, %68 ]
  %49 = phi i1 [ %40, %37 ], [ true, %52 ], [ false, %68 ]
  %50 = phi i1 [ true, %37 ], [ %41, %52 ], [ %41, %68 ]
  %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 %163, label %58, !prof !6

58:                                               ; preds = %53, %54
  %59 = phi i64 [ %56, %54 ], [ %39, %53 ]
  br label %73

60:                                               ; preds = %44
  %.4 = select i1 %40, i64 0, i64 %39
  %61 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.4, i64 10)
  %62 = extractvalue { i64, i1 } %61, 1
  br i1 %62, label %152, label %63, !prof !6

63:                                               ; preds = %60
  %64 = extractvalue { i64, i1 } %61, 0
  %65 = zext i8 %38 to i64
  %66 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %64, i64 %65)
  %67 = extractvalue { i64, i1 } %66, 1
  br i1 %67, label %153, label %68, !prof !6

68:                                               ; preds = %63
  %69 = extractvalue { i64, i1 } %66, 0
  %70 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %69, i64 -48)
  %71 = extractvalue { i64, i1 } %70, 0
  %72 = extractvalue { i64, i1 } %70, 1
  br i1 %72, label %154, label %47, !prof !6

73:                                               ; preds = %83, %58
  %74 = phi i8 [ %38, %58 ], [ %.pre97, %83 ]
  %75 = phi i64 [ 0, %58 ], [ %84, %83 ]
  %76 = phi i1 [ true, %58 ], [ %85, %83 ]
  %77 = phi i1 [ false, %58 ], [ %86, %83 ]
  %78 = phi i8* [ %42, %58 ], [ %87, %83 ]
  %79 = icmp eq i8 %74, 45
  br i1 %79, label %83, label %80

80:                                               ; preds = %73
  %81 = add i8 %74, -58
  %82 = icmp ult i8 %81, -10
  br i1 %82, label %88, label %96

83:                                               ; preds = %104, %88, %73
  %84 = phi i64 [ %75, %73 ], [ %75, %88 ], [ %107, %104 ]
  %85 = phi i1 [ %76, %73 ], [ true, %88 ], [ false, %104 ]
  %86 = phi i1 [ true, %73 ], [ %77, %88 ], [ %77, %104 ]
  %87 = getelementptr inbounds i8, i8* %78, i64 1
  %.pre97 = load i8, i8* %87, align 1
  br label %73

88:                                               ; preds = %80
  br i1 %76, label %83, label %89

89:                                               ; preds = %88
  br i1 %77, label %90, label %94

90:                                               ; preds = %89
  %91 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %75)
  %92 = extractvalue { i64, i1 } %91, 0
  %93 = extractvalue { i64, i1 } %91, 1
  br i1 %93, label %162, label %94, !prof !6

94:                                               ; preds = %89, %90
  %95 = phi i64 [ %92, %90 ], [ %75, %89 ]
  br label %109

96:                                               ; preds = %80
  %.5 = select i1 %76, i64 0, i64 %75
  %97 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.5, i64 10)
  %98 = extractvalue { i64, i1 } %97, 1
  br i1 %98, label %155, label %99, !prof !6

99:                                               ; preds = %96
  %100 = extractvalue { i64, i1 } %97, 0
  %101 = zext i8 %74 to i64
  %102 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %100, i64 %101)
  %103 = extractvalue { i64, i1 } %102, 1
  br i1 %103, label %156, label %104, !prof !6

104:                                              ; preds = %99
  %105 = extractvalue { i64, i1 } %102, 0
  %106 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %105, i64 -48)
  %107 = extractvalue { i64, i1 } %106, 0
  %108 = extractvalue { i64, i1 } %106, 1
  br i1 %108, label %157, label %83, !prof !6

109:                                              ; preds = %119, %94
  %110 = phi i8 [ %74, %94 ], [ %.pre98, %119 ]
  %111 = phi i64 [ 0, %94 ], [ %120, %119 ]
  %112 = phi i1 [ true, %94 ], [ %121, %119 ]
  %113 = phi i1 [ false, %94 ], [ %122, %119 ]
  %114 = phi i8* [ %78, %94 ], [ %123, %119 ]
  %115 = icmp eq i8 %110, 45
  br i1 %115, label %119, label %116

116:                                              ; preds = %109
  %117 = add i8 %110, -58
  %118 = icmp ult i8 %117, -10
  br i1 %118, label %124, label %136

119:                                              ; preds = %144, %124, %109
  %120 = phi i64 [ %111, %109 ], [ %111, %124 ], [ %147, %144 ]
  %121 = phi i1 [ %112, %109 ], [ true, %124 ], [ false, %144 ]
  %122 = phi i1 [ true, %109 ], [ %113, %124 ], [ %113, %144 ]
  %123 = getelementptr inbounds i8, i8* %114, i64 1
  %.pre98 = load i8, i8* %123, align 1
  br label %109

124:                                              ; preds = %116
  br i1 %112, label %119, label %125

125:                                              ; preds = %124
  br i1 %113, label %126, label %130

126:                                              ; preds = %125
  %127 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %111)
  %128 = extractvalue { i64, i1 } %127, 0
  %129 = extractvalue { i64, i1 } %127, 1
  br i1 %129, label %161, label %130, !prof !6

130:                                              ; preds = %125, %126
  %131 = phi i64 [ %128, %126 ], [ %111, %125 ]
  %132 = insertvalue { i64, i64, i64, i64 } undef, i64 %23, 0
  %133 = insertvalue { i64, i64, i64, i64 } %132, i64 %59, 1
  %134 = insertvalue { i64, i64, i64, i64 } %133, i64 %95, 2
  %135 = insertvalue { i64, i64, i64, i64 } %134, i64 %131, 3
  ret { i64, i64, i64, i64 } %135

136:                                              ; preds = %116
  %.6 = select i1 %112, i64 0, i64 %111
  %137 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.6, i64 10)
  %138 = extractvalue { i64, i1 } %137, 1
  br i1 %138, label %158, label %139, !prof !6

139:                                              ; preds = %136
  %140 = extractvalue { i64, i1 } %137, 0
  %141 = zext i8 %110 to i64
  %142 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %140, i64 %141)
  %143 = extractvalue { i64, i1 } %142, 1
  br i1 %143, label %159, label %144, !prof !6

144:                                              ; preds = %139
  %145 = extractvalue { i64, i1 } %142, 0
  %146 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %145, i64 -48)
  %147 = extractvalue { i64, i1 } %146, 0
  %148 = extractvalue { i64, i1 } %146, 1
  br i1 %148, label %160, label %119, !prof !6

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

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

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

152:                                              ; preds = %60
  tail call void asm sideeffect "", "n"(i32 3) #5
  tail call void @llvm.trap()
  unreachable

153:                                              ; preds = %63
  tail call void asm sideeffect "", "n"(i32 4) #5
  tail call void @llvm.trap()
  unreachable

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

155:                                              ; preds = %96
  tail call void asm sideeffect "", "n"(i32 6) #5
  tail call void @llvm.trap()
  unreachable

156:                                              ; preds = %99
  tail call void asm sideeffect "", "n"(i32 7) #5
  tail call void @llvm.trap()
  unreachable

157:                                              ; preds = %104
  tail call void asm sideeffect "", "n"(i32 8) #5
  tail call void @llvm.trap()
  unreachable

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

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

160:                                              ; preds = %144
  tail call void asm sideeffect "", "n"(i32 11) #5
  tail call void @llvm.trap()
  unreachable

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

162:                                              ; preds = %90
  tail call void asm sideeffect "", "n"(i32 13) #5
  tail call void @llvm.trap()
  unreachable

163:                                              ; preds = %54
  tail call void asm sideeffect "", "n"(i32 14) #5
  tail call void @llvm.trap()
  unreachable

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

define hidden swiftcc void @"$s7llvm_O316getIntQuintupletSi_S4ityF"(<{ %TSi, %TSi, %TSi, %TSi, %TSi }>* noalias nocapture writeonly sret(<{ %TSi, %TSi, %TSi, %TSi, %TSi }>) %0) local_unnamed_addr #0 {
entry:
  %1 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 120)
  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 i8* [ %1, %entry ], [ %16, %12 ]
  %7 = load i8, i8* %6, 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 i8, i8* %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 %201, label %23, !prof !6

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

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 %182, label %28, !prof !6

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 %183, label %33, !prof !6

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 %184, label %12, !prof !6

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

45:                                               ; preds = %38
  %46 = add i8 %39, -58
  %47 = icmp ult i8 %46, -10
  br i1 %47, label %53, label %61

48:                                               ; preds = %69, %53, %38
  %49 = phi i64 [ %40, %38 ], [ %40, %53 ], [ %72, %69 ]
  %50 = phi i1 [ %41, %38 ], [ true, %53 ], [ false, %69 ]
  %51 = phi i1 [ true, %38 ], [ %42, %53 ], [ %42, %69 ]
  %52 = getelementptr inbounds i8, i8* %43, i64 1
  %.pre = load i8, i8* %52, align 1
  br label %38

53:                                               ; preds = %45
  br i1 %41, label %48, label %54

54:                                               ; preds = %53
  br i1 %42, label %55, label %59

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

59:                                               ; preds = %54, %55
  %60 = phi i64 [ %57, %55 ], [ %40, %54 ]
  br label %74

61:                                               ; preds = %45
  %.9 = select i1 %41, i64 0, i64 %40
  %62 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.9, i64 10)
  %63 = extractvalue { i64, i1 } %62, 1
  br i1 %63, label %185, label %64, !prof !6

64:                                               ; preds = %61
  %65 = extractvalue { i64, i1 } %62, 0
  %66 = zext i8 %39 to i64
  %67 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %65, i64 %66)
  %68 = extractvalue { i64, i1 } %67, 1
  br i1 %68, label %186, label %69, !prof !6

69:                                               ; preds = %64
  %70 = extractvalue { i64, i1 } %67, 0
  %71 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %70, i64 -48)
  %72 = extractvalue { i64, i1 } %71, 0
  %73 = extractvalue { i64, i1 } %71, 1
  br i1 %73, label %187, label %48, !prof !6

74:                                               ; preds = %84, %59
  %75 = phi i8 [ %39, %59 ], [ %.pre128, %84 ]
  %76 = phi i64 [ 0, %59 ], [ %85, %84 ]
  %77 = phi i1 [ true, %59 ], [ %86, %84 ]
  %78 = phi i1 [ false, %59 ], [ %87, %84 ]
  %79 = phi i8* [ %43, %59 ], [ %88, %84 ]
  %80 = icmp eq i8 %75, 45
  br i1 %80, label %84, label %81

81:                                               ; preds = %74
  %82 = add i8 %75, -58
  %83 = icmp ult i8 %82, -10
  br i1 %83, label %89, label %97

84:                                               ; preds = %105, %89, %74
  %85 = phi i64 [ %76, %74 ], [ %76, %89 ], [ %108, %105 ]
  %86 = phi i1 [ %77, %74 ], [ true, %89 ], [ false, %105 ]
  %87 = phi i1 [ true, %74 ], [ %78, %89 ], [ %78, %105 ]
  %88 = getelementptr inbounds i8, i8* %79, i64 1
  %.pre128 = load i8, i8* %88, align 1
  br label %74

89:                                               ; preds = %81
  br i1 %77, label %84, label %90

90:                                               ; preds = %89
  br i1 %78, label %91, label %95

91:                                               ; preds = %90
  %92 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %76)
  %93 = extractvalue { i64, i1 } %92, 0
  %94 = extractvalue { i64, i1 } %92, 1
  br i1 %94, label %199, label %95, !prof !6

95:                                               ; preds = %90, %91
  %96 = phi i64 [ %93, %91 ], [ %76, %90 ]
  br label %110

97:                                               ; preds = %81
  %.10 = select i1 %77, i64 0, i64 %76
  %98 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.10, i64 10)
  %99 = extractvalue { i64, i1 } %98, 1
  br i1 %99, label %188, label %100, !prof !6

100:                                              ; preds = %97
  %101 = extractvalue { i64, i1 } %98, 0
  %102 = zext i8 %75 to i64
  %103 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %101, i64 %102)
  %104 = extractvalue { i64, i1 } %103, 1
  br i1 %104, label %189, label %105, !prof !6

105:                                              ; preds = %100
  %106 = extractvalue { i64, i1 } %103, 0
  %107 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %106, i64 -48)
  %108 = extractvalue { i64, i1 } %107, 0
  %109 = extractvalue { i64, i1 } %107, 1
  br i1 %109, label %190, label %84, !prof !6

110:                                              ; preds = %120, %95
  %111 = phi i8 [ %75, %95 ], [ %.pre129, %120 ]
  %112 = phi i64 [ 0, %95 ], [ %121, %120 ]
  %113 = phi i1 [ true, %95 ], [ %122, %120 ]
  %114 = phi i1 [ false, %95 ], [ %123, %120 ]
  %115 = phi i8* [ %79, %95 ], [ %124, %120 ]
  %116 = icmp eq i8 %111, 45
  br i1 %116, label %120, label %117

117:                                              ; preds = %110
  %118 = add i8 %111, -58
  %119 = icmp ult i8 %118, -10
  br i1 %119, label %125, label %133

120:                                              ; preds = %141, %125, %110
  %121 = phi i64 [ %112, %110 ], [ %112, %125 ], [ %144, %141 ]
  %122 = phi i1 [ %113, %110 ], [ true, %125 ], [ false, %141 ]
  %123 = phi i1 [ true, %110 ], [ %114, %125 ], [ %114, %141 ]
  %124 = getelementptr inbounds i8, i8* %115, i64 1
  %.pre129 = load i8, i8* %124, align 1
  br label %110

125:                                              ; preds = %117
  br i1 %113, label %120, label %126

126:                                              ; preds = %125
  br i1 %114, label %127, label %131

127:                                              ; preds = %126
  %128 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %112)
  %129 = extractvalue { i64, i1 } %128, 0
  %130 = extractvalue { i64, i1 } %128, 1
  br i1 %130, label %198, label %131, !prof !6

131:                                              ; preds = %126, %127
  %132 = phi i64 [ %129, %127 ], [ %112, %126 ]
  br label %146

133:                                              ; preds = %117
  %.11 = select i1 %113, i64 0, i64 %112
  %134 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.11, i64 10)
  %135 = extractvalue { i64, i1 } %134, 1
  br i1 %135, label %191, label %136, !prof !6

136:                                              ; preds = %133
  %137 = extractvalue { i64, i1 } %134, 0
  %138 = zext i8 %111 to i64
  %139 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %137, i64 %138)
  %140 = extractvalue { i64, i1 } %139, 1
  br i1 %140, label %192, label %141, !prof !6

141:                                              ; preds = %136
  %142 = extractvalue { i64, i1 } %139, 0
  %143 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %142, i64 -48)
  %144 = extractvalue { i64, i1 } %143, 0
  %145 = extractvalue { i64, i1 } %143, 1
  br i1 %145, label %193, label %120, !prof !6

146:                                              ; preds = %156, %131
  %147 = phi i8 [ %111, %131 ], [ %.pre130, %156 ]
  %148 = phi i64 [ 0, %131 ], [ %157, %156 ]
  %149 = phi i1 [ true, %131 ], [ %158, %156 ]
  %150 = phi i1 [ false, %131 ], [ %159, %156 ]
  %151 = phi i8* [ %115, %131 ], [ %160, %156 ]
  %152 = icmp eq i8 %147, 45
  br i1 %152, label %156, label %153

153:                                              ; preds = %146
  %154 = add i8 %147, -58
  %155 = icmp ult i8 %154, -10
  br i1 %155, label %161, label %169

156:                                              ; preds = %177, %161, %146
  %157 = phi i64 [ %148, %146 ], [ %148, %161 ], [ %180, %177 ]
  %158 = phi i1 [ %149, %146 ], [ true, %161 ], [ false, %177 ]
  %159 = phi i1 [ true, %146 ], [ %150, %161 ], [ %150, %177 ]
  %160 = getelementptr inbounds i8, i8* %151, i64 1
  %.pre130 = load i8, i8* %160, align 1
  br label %146

161:                                              ; preds = %153
  br i1 %149, label %156, label %162

162:                                              ; preds = %161
  br i1 %150, label %163, label %167

163:                                              ; preds = %162
  %164 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %148)
  %165 = extractvalue { i64, i1 } %164, 0
  %166 = extractvalue { i64, i1 } %164, 1
  br i1 %166, label %197, label %167, !prof !6

167:                                              ; preds = %162, %163
  %168 = phi i64 [ %165, %163 ], [ %148, %162 ]
  %.elt._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 0, i32 0
  store i64 %24, i64* %.elt._value, align 8
  %.elt5._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 1, i32 0
  store i64 %60, i64* %.elt5._value, align 8
  %.elt6._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 2, i32 0
  store i64 %96, i64* %.elt6._value, align 8
  %.elt7._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 3, i32 0
  store i64 %132, i64* %.elt7._value, align 8
  %.elt8._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 4, i32 0
  store i64 %168, i64* %.elt8._value, align 8
  ret void

169:                                              ; preds = %153
  %.12 = select i1 %149, i64 0, i64 %148
  %170 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.12, i64 10)
  %171 = extractvalue { i64, i1 } %170, 1
  br i1 %171, label %194, label %172, !prof !6

172:                                              ; preds = %169
  %173 = extractvalue { i64, i1 } %170, 0
  %174 = zext i8 %147 to i64
  %175 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %173, i64 %174)
  %176 = extractvalue { i64, i1 } %175, 1
  br i1 %176, label %195, label %177, !prof !6

177:                                              ; preds = %172
  %178 = extractvalue { i64, i1 } %175, 0
  %179 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %178, i64 -48)
  %180 = extractvalue { i64, i1 } %179, 0
  %181 = extractvalue { i64, i1 } %179, 1
  br i1 %181, label %196, label %156, !prof !6

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

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

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

185:                                              ; preds = %61
  tail call void asm sideeffect "", "n"(i32 3) #5
  tail call void @llvm.trap()
  unreachable

186:                                              ; preds = %64
  tail call void asm sideeffect "", "n"(i32 4) #5
  tail call void @llvm.trap()
  unreachable

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

188:                                              ; preds = %97
  tail call void asm sideeffect "", "n"(i32 6) #5
  tail call void @llvm.trap()
  unreachable

189:                                              ; preds = %100
  tail call void asm sideeffect "", "n"(i32 7) #5
  tail call void @llvm.trap()
  unreachable

190:                                              ; preds = %105
  tail call void asm sideeffect "", "n"(i32 8) #5
  tail call void @llvm.trap()
  unreachable

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

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

193:                                              ; preds = %141
  tail call void asm sideeffect "", "n"(i32 11) #5
  tail call void @llvm.trap()
  unreachable

194:                                              ; preds = %169
  tail call void asm sideeffect "", "n"(i32 12) #5
  tail call void @llvm.trap()
  unreachable

195:                                              ; preds = %172
  tail call void asm sideeffect "", "n"(i32 13) #5
  tail call void @llvm.trap()
  unreachable

196:                                              ; preds = %177
  tail call void asm sideeffect "", "n"(i32 14) #5
  tail call void @llvm.trap()
  unreachable

197:                                              ; preds = %163
  tail call void asm sideeffect "", "n"(i32 15) #5
  tail call void @llvm.trap()
  unreachable

198:                                              ; preds = %127
  tail call void asm sideeffect "", "n"(i32 16) #5
  tail call void @llvm.trap()
  unreachable

199:                                              ; preds = %91
  tail call void asm sideeffect "", "n"(i32 17) #5
  tail call void @llvm.trap()
  unreachable

200:                                              ; preds = %55
  tail call void asm sideeffect "", "n"(i32 18) #5
  tail call void @llvm.trap()
  unreachable

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

define hidden swiftcc void @"$s7llvm_O315getIntSextupletSi_S5ityF"(<{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* noalias nocapture writeonly sret(<{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>) %0) local_unnamed_addr #0 {
entry:
  %1 = tail call swiftcc i8* @"$s7llvm_O312getsToBuffer33_73E641EE209B6240D9CA5E4E565FCA33LL4sizeSpys4Int8VGs5Int32V_tF"(i32 144)
  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 i8* [ %1, %entry ], [ %16, %12 ]
  %7 = load i8, i8* %6, 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 i8, i8* %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 %241, label %23, !prof !6

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

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 %218, label %28, !prof !6

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 %219, label %33, !prof !6

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 %220, label %12, !prof !6

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

45:                                               ; preds = %38
  %46 = add i8 %39, -58
  %47 = icmp ult i8 %46, -10
  br i1 %47, label %53, label %61

48:                                               ; preds = %69, %53, %38
  %49 = phi i64 [ %40, %38 ], [ %40, %53 ], [ %72, %69 ]
  %50 = phi i1 [ %41, %38 ], [ true, %53 ], [ false, %69 ]
  %51 = phi i1 [ true, %38 ], [ %42, %53 ], [ %42, %69 ]
  %52 = getelementptr inbounds i8, i8* %43, i64 1
  %.pre = load i8, i8* %52, align 1
  br label %38

53:                                               ; preds = %45
  br i1 %41, label %48, label %54

54:                                               ; preds = %53
  br i1 %42, label %55, label %59

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

59:                                               ; preds = %54, %55
  %60 = phi i64 [ %57, %55 ], [ %40, %54 ]
  br label %74

61:                                               ; preds = %45
  %.11 = select i1 %41, i64 0, i64 %40
  %62 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.11, i64 10)
  %63 = extractvalue { i64, i1 } %62, 1
  br i1 %63, label %221, label %64, !prof !6

64:                                               ; preds = %61
  %65 = extractvalue { i64, i1 } %62, 0
  %66 = zext i8 %39 to i64
  %67 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %65, i64 %66)
  %68 = extractvalue { i64, i1 } %67, 1
  br i1 %68, label %222, label %69, !prof !6

69:                                               ; preds = %64
  %70 = extractvalue { i64, i1 } %67, 0
  %71 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %70, i64 -48)
  %72 = extractvalue { i64, i1 } %71, 0
  %73 = extractvalue { i64, i1 } %71, 1
  br i1 %73, label %223, label %48, !prof !6

74:                                               ; preds = %84, %59
  %75 = phi i8 [ %39, %59 ], [ %.pre156, %84 ]
  %76 = phi i64 [ 0, %59 ], [ %85, %84 ]
  %77 = phi i1 [ true, %59 ], [ %86, %84 ]
  %78 = phi i1 [ false, %59 ], [ %87, %84 ]
  %79 = phi i8* [ %43, %59 ], [ %88, %84 ]
  %80 = icmp eq i8 %75, 45
  br i1 %80, label %84, label %81

81:                                               ; preds = %74
  %82 = add i8 %75, -58
  %83 = icmp ult i8 %82, -10
  br i1 %83, label %89, label %97

84:                                               ; preds = %105, %89, %74
  %85 = phi i64 [ %76, %74 ], [ %76, %89 ], [ %108, %105 ]
  %86 = phi i1 [ %77, %74 ], [ true, %89 ], [ false, %105 ]
  %87 = phi i1 [ true, %74 ], [ %78, %89 ], [ %78, %105 ]
  %88 = getelementptr inbounds i8, i8* %79, i64 1
  %.pre156 = load i8, i8* %88, align 1
  br label %74

89:                                               ; preds = %81
  br i1 %77, label %84, label %90

90:                                               ; preds = %89
  br i1 %78, label %91, label %95

91:                                               ; preds = %90
  %92 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %76)
  %93 = extractvalue { i64, i1 } %92, 0
  %94 = extractvalue { i64, i1 } %92, 1
  br i1 %94, label %239, label %95, !prof !6

95:                                               ; preds = %90, %91
  %96 = phi i64 [ %93, %91 ], [ %76, %90 ]
  br label %110

97:                                               ; preds = %81
  %.12 = select i1 %77, i64 0, i64 %76
  %98 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.12, i64 10)
  %99 = extractvalue { i64, i1 } %98, 1
  br i1 %99, label %224, label %100, !prof !6

100:                                              ; preds = %97
  %101 = extractvalue { i64, i1 } %98, 0
  %102 = zext i8 %75 to i64
  %103 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %101, i64 %102)
  %104 = extractvalue { i64, i1 } %103, 1
  br i1 %104, label %225, label %105, !prof !6

105:                                              ; preds = %100
  %106 = extractvalue { i64, i1 } %103, 0
  %107 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %106, i64 -48)
  %108 = extractvalue { i64, i1 } %107, 0
  %109 = extractvalue { i64, i1 } %107, 1
  br i1 %109, label %226, label %84, !prof !6

110:                                              ; preds = %120, %95
  %111 = phi i8 [ %75, %95 ], [ %.pre157, %120 ]
  %112 = phi i64 [ 0, %95 ], [ %121, %120 ]
  %113 = phi i1 [ true, %95 ], [ %122, %120 ]
  %114 = phi i1 [ false, %95 ], [ %123, %120 ]
  %115 = phi i8* [ %79, %95 ], [ %124, %120 ]
  %116 = icmp eq i8 %111, 45
  br i1 %116, label %120, label %117

117:                                              ; preds = %110
  %118 = add i8 %111, -58
  %119 = icmp ult i8 %118, -10
  br i1 %119, label %125, label %133

120:                                              ; preds = %141, %125, %110
  %121 = phi i64 [ %112, %110 ], [ %112, %125 ], [ %144, %141 ]
  %122 = phi i1 [ %113, %110 ], [ true, %125 ], [ false, %141 ]
  %123 = phi i1 [ true, %110 ], [ %114, %125 ], [ %114, %141 ]
  %124 = getelementptr inbounds i8, i8* %115, i64 1
  %.pre157 = load i8, i8* %124, align 1
  br label %110

125:                                              ; preds = %117
  br i1 %113, label %120, label %126

126:                                              ; preds = %125
  br i1 %114, label %127, label %131

127:                                              ; preds = %126
  %128 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %112)
  %129 = extractvalue { i64, i1 } %128, 0
  %130 = extractvalue { i64, i1 } %128, 1
  br i1 %130, label %238, label %131, !prof !6

131:                                              ; preds = %126, %127
  %132 = phi i64 [ %129, %127 ], [ %112, %126 ]
  br label %146

133:                                              ; preds = %117
  %.13 = select i1 %113, i64 0, i64 %112
  %134 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.13, i64 10)
  %135 = extractvalue { i64, i1 } %134, 1
  br i1 %135, label %227, label %136, !prof !6

136:                                              ; preds = %133
  %137 = extractvalue { i64, i1 } %134, 0
  %138 = zext i8 %111 to i64
  %139 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %137, i64 %138)
  %140 = extractvalue { i64, i1 } %139, 1
  br i1 %140, label %228, label %141, !prof !6

141:                                              ; preds = %136
  %142 = extractvalue { i64, i1 } %139, 0
  %143 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %142, i64 -48)
  %144 = extractvalue { i64, i1 } %143, 0
  %145 = extractvalue { i64, i1 } %143, 1
  br i1 %145, label %229, label %120, !prof !6

146:                                              ; preds = %156, %131
  %147 = phi i8 [ %111, %131 ], [ %.pre158, %156 ]
  %148 = phi i64 [ 0, %131 ], [ %157, %156 ]
  %149 = phi i1 [ true, %131 ], [ %158, %156 ]
  %150 = phi i1 [ false, %131 ], [ %159, %156 ]
  %151 = phi i8* [ %115, %131 ], [ %160, %156 ]
  %152 = icmp eq i8 %147, 45
  br i1 %152, label %156, label %153

153:                                              ; preds = %146
  %154 = add i8 %147, -58
  %155 = icmp ult i8 %154, -10
  br i1 %155, label %161, label %169

156:                                              ; preds = %177, %161, %146
  %157 = phi i64 [ %148, %146 ], [ %148, %161 ], [ %180, %177 ]
  %158 = phi i1 [ %149, %146 ], [ true, %161 ], [ false, %177 ]
  %159 = phi i1 [ true, %146 ], [ %150, %161 ], [ %150, %177 ]
  %160 = getelementptr inbounds i8, i8* %151, i64 1
  %.pre158 = load i8, i8* %160, align 1
  br label %146

161:                                              ; preds = %153
  br i1 %149, label %156, label %162

162:                                              ; preds = %161
  br i1 %150, label %163, label %167

163:                                              ; preds = %162
  %164 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %148)
  %165 = extractvalue { i64, i1 } %164, 0
  %166 = extractvalue { i64, i1 } %164, 1
  br i1 %166, label %237, label %167, !prof !6

167:                                              ; preds = %162, %163
  %168 = phi i64 [ %165, %163 ], [ %148, %162 ]
  br label %182

169:                                              ; preds = %153
  %.14 = select i1 %149, i64 0, i64 %148
  %170 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.14, i64 10)
  %171 = extractvalue { i64, i1 } %170, 1
  br i1 %171, label %230, label %172, !prof !6

172:                                              ; preds = %169
  %173 = extractvalue { i64, i1 } %170, 0
  %174 = zext i8 %147 to i64
  %175 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %173, i64 %174)
  %176 = extractvalue { i64, i1 } %175, 1
  br i1 %176, label %231, label %177, !prof !6

177:                                              ; preds = %172
  %178 = extractvalue { i64, i1 } %175, 0
  %179 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %178, i64 -48)
  %180 = extractvalue { i64, i1 } %179, 0
  %181 = extractvalue { i64, i1 } %179, 1
  br i1 %181, label %232, label %156, !prof !6

182:                                              ; preds = %192, %167
  %183 = phi i8 [ %147, %167 ], [ %.pre159, %192 ]
  %184 = phi i64 [ 0, %167 ], [ %193, %192 ]
  %185 = phi i1 [ true, %167 ], [ %194, %192 ]
  %186 = phi i1 [ false, %167 ], [ %195, %192 ]
  %187 = phi i8* [ %151, %167 ], [ %196, %192 ]
  %188 = icmp eq i8 %183, 45
  br i1 %188, label %192, label %189

189:                                              ; preds = %182
  %190 = add i8 %183, -58
  %191 = icmp ult i8 %190, -10
  br i1 %191, label %197, label %205

192:                                              ; preds = %213, %197, %182
  %193 = phi i64 [ %184, %182 ], [ %184, %197 ], [ %216, %213 ]
  %194 = phi i1 [ %185, %182 ], [ true, %197 ], [ false, %213 ]
  %195 = phi i1 [ true, %182 ], [ %186, %197 ], [ %186, %213 ]
  %196 = getelementptr inbounds i8, i8* %187, i64 1
  %.pre159 = load i8, i8* %196, align 1
  br label %182

197:                                              ; preds = %189
  br i1 %185, label %192, label %198

198:                                              ; preds = %197
  br i1 %186, label %199, label %203

199:                                              ; preds = %198
  %200 = tail call { i64, i1 } @llvm.ssub.with.overflow.i64(i64 0, i64 %184)
  %201 = extractvalue { i64, i1 } %200, 0
  %202 = extractvalue { i64, i1 } %200, 1
  br i1 %202, label %236, label %203, !prof !6

203:                                              ; preds = %198, %199
  %204 = phi i64 [ %201, %199 ], [ %184, %198 ]
  %.elt._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 0, i32 0
  store i64 %24, i64* %.elt._value, align 8
  %.elt6._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 1, i32 0
  store i64 %60, i64* %.elt6._value, align 8
  %.elt7._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 2, i32 0
  store i64 %96, i64* %.elt7._value, align 8
  %.elt8._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 3, i32 0
  store i64 %132, i64* %.elt8._value, align 8
  %.elt9._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 4, i32 0
  store i64 %168, i64* %.elt9._value, align 8
  %.elt10._value = getelementptr inbounds <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>, <{ %TSi, %TSi, %TSi, %TSi, %TSi, %TSi }>* %0, i64 0, i32 5, i32 0
  store i64 %204, i64* %.elt10._value, align 8
  ret void

205:                                              ; preds = %189
  %.15 = select i1 %185, i64 0, i64 %184
  %206 = tail call { i64, i1 } @llvm.smul.with.overflow.i64(i64 %.15, i64 10)
  %207 = extractvalue { i64, i1 } %206, 1
  br i1 %207, label %233, label %208, !prof !6

208:                                              ; preds = %205
  %209 = extractvalue { i64, i1 } %206, 0
  %210 = zext i8 %183 to i64
  %211 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %209, i64 %210)
  %212 = extractvalue { i64, i1 } %211, 1
  br i1 %212, label %234, label %213, !prof !6

213:                                              ; preds = %208
  %214 = extractvalue { i64, i1 } %211, 0
  %215 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %214, i64 -48)
  %216 = extractvalue { i64, i1 } %215, 0
  %217 = extractvalue { i64, i1 } %215, 1
  br i1 %217, label %235, label %192, !prof !6

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

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

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

221:                                              ; preds = %61
  tail call void asm sideeffect "", "n"(i32 3) #5
  tail call void @llvm.trap()
  unreachable

222:                                              ; preds = %64
  tail call void asm sideeffect "", "n"(i32 4) #5
  tail call void @llvm.trap()
  unreachable

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

224:                                              ; preds = %97
  tail call void asm sideeffect "", "n"(i32 6) #5
  tail call void @llvm.trap()
  unreachable

225:                                              ; preds = %100
  tail call void asm sideeffect "", "n"(i32 7) #5
  tail call void @llvm.trap()
  unreachable

226:                                              ; preds = %105
  tail call void asm sideeffect "", "n"(i32 8) #5
  tail call void @llvm.trap()
  unreachable

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

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

229:                                              ; preds = %141
  tail call void asm sideeffect "", "n"(i32 11) #5
  tail call void @llvm.trap()
  unreachable

230:                                              ; preds = %169
  tail call void asm sideeffect "", "n"(i32 12) #5
  tail call void @llvm.trap()
  unreachable

231:                                              ; preds = %172
  tail call void asm sideeffect "", "n"(i32 13) #5
  tail call void @llvm.trap()
  unreachable

232:                                              ; preds = %177
  tail call void asm sideeffect "", "n"(i32 14) #5
  tail call void @llvm.trap()
  unreachable

233:                                              ; preds = %205
  tail call void asm sideeffect "", "n"(i32 15) #5
  tail call void @llvm.trap()
  unreachable

234:                                              ; preds = %208
  tail call void asm sideeffect "", "n"(i32 16) #5
  tail call void @llvm.trap()
  unreachable

235:                                              ; preds = %213
  tail call void asm sideeffect "", "n"(i32 17) #5
  tail call void @llvm.trap()
  unreachable

236:                                              ; preds = %199
  tail call void asm sideeffect "", "n"(i32 18) #5
  tail call void @llvm.trap()
  unreachable

237:                                              ; preds = %163
  tail call void asm sideeffect "", "n"(i32 19) #5
  tail call void @llvm.trap()
  unreachable

238:                                              ; preds = %127
  tail call void asm sideeffect "", "n"(i32 20) #5
  tail call void @llvm.trap()
  unreachable

239:                                              ; preds = %91
  tail call void asm sideeffect "", "n"(i32 21) #5
  tail call void @llvm.trap()
  unreachable

240:                                              ; preds = %55
  tail call void asm sideeffect "", "n"(i32 22) #5
  tail call void @llvm.trap()
  unreachable

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

declare swiftcc { %Ts28__ContiguousArrayStorageBaseC*, i8* } @"$sSa22_allocateUninitializedySayxG_SpyxGtSiFZ"(i64, %swift.type*) local_unnamed_addr #0

; Function Attrs: noinline
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #13 {
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 %46, label %11, !prof !6

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 !7
  %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") #29
  %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) #5
  %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) #31
  %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
  %32 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to i8*
  %33 = getelementptr inbounds %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 1
  %34 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to i8*
  br i1 %0, label %35, label %42

35:                                               ; preds = %29
  %tailaddr4 = bitcast %Ts28__ContiguousArrayStorageBaseC* %33 to %TSi*
  %36 = getelementptr inbounds %TSi, %TSi* %tailaddr4, i64 %16
  %37 = bitcast %TSi* %36 to %Ts28__ContiguousArrayStorageBaseC*
  %38 = icmp ult %Ts28__ContiguousArrayStorageBaseC* %31, %37
  %39 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond14 = select i1 %39, i1 %38, i1 false
  br i1 %or.cond14, label %41, label %.sink.split

.sink.split:                                      ; preds = %35
  %40 = shl nuw i64 %16, 3
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 8 %32, i8* nonnull align 8 %34, i64 %40, i1 false)
  br label %41

41:                                               ; preds = %35, %.sink.split
  store i64 0, i64* %._storage.count._value, align 8
  br label %44

42:                                               ; preds = %29
  %43 = shl nuw i64 %16, 3
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 8 %32, i8* nonnull align 8 %34, i64 %43, i1 false)
  br label %44

44:                                               ; preds = %41, %42
  %45 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %45) #5
  ret %Ts28__ContiguousArrayStorageBaseC* %30

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

; Function Attrs: mustprogress nofree noinline nounwind readonly willreturn
define linkonce_odr hidden %swift.type* @__swift_instantiateConcreteTypeFromMangledName({ i32, i32 }* %0) local_unnamed_addr #14 {
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 !6

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) #32
  %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 #15

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

; Function Attrs: noinline
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSS_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #13 {
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 !6

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 !7
  %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") #29
  %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) #5
  %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) #31
  %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
  %tailaddr4 = bitcast %Ts28__ContiguousArrayStorageBaseC* %32 to %TSS*
  %34 = getelementptr inbounds %TSS, %TSS* %tailaddr4, i64 %16
  %35 = bitcast %TSS* %34 to %Ts28__ContiguousArrayStorageBaseC*
  %36 = icmp ult %Ts28__ContiguousArrayStorageBaseC* %31, %35
  %37 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %30, %3
  %or.cond14 = select i1 %37, i1 %36, i1 false
  br i1 %or.cond14, label %41, label %.sink.split

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

41:                                               ; preds = %33, %.sink.split
  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") #28
  br label %45

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

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

; Function Attrs: noinline
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFs5UInt8V_Tg5"(i1 %0, i64 %1, i1 %2, %Ts28__ContiguousArrayStorageBaseC* %3) local_unnamed_addr #13 {
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 %41, label %11, !prof !6

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 !7
  %17 = tail call i64 @llvm.smax.i64(i64 %15, i64 %16)
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %27, label %19

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

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

33:                                               ; preds = %27
  %tailaddr4 = bitcast %Ts28__ContiguousArrayStorageBaseC* %31 to %Ts5UInt8V*
  %34 = getelementptr inbounds %Ts5UInt8V, %Ts5UInt8V* %tailaddr4, i64 %16, i32 0
  %35 = icmp ugt i8* %34, %30
  %36 = icmp eq %Ts28__ContiguousArrayStorageBaseC* %28, %3
  %or.cond14 = select i1 %36, i1 %35, i1 false
  br i1 %or.cond14, label %37, label %.sink.split

.sink.split:                                      ; preds = %33
  tail call void @llvm.memmove.p0i8.p0i8.i64(i8* nonnull align 1 %30, i8* nonnull align 1 %32, i64 %16, i1 false)
  br label %37

37:                                               ; preds = %33, %.sink.split
  store i64 0, i64* %._storage.count._value, align 8
  br label %39

38:                                               ; preds = %27
  tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* nonnull align 1 %30, i8* nonnull align 1 %32, i64 %16, i1 false)
  br label %39

39:                                               ; preds = %37, %38
  %40 = getelementptr %Ts28__ContiguousArrayStorageBaseC, %Ts28__ContiguousArrayStorageBaseC* %3, i64 0, i32 0
  tail call void @swift_release(%swift.refcounted* %40) #5
  ret %Ts28__ContiguousArrayStorageBaseC* %28

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

; Function Attrs: noinline
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 #13 {
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
}

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

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

; Function Attrs: nofree noinline nosync nounwind readnone
define linkonce_odr hidden i8** @"$sSaySSGSayxGSKsWl"() local_unnamed_addr #16 {
entry:
  %0 = load i8**, i8*** @"$sSaySSGSayxGSKsWL", align 8
  %1 = icmp eq i8** %0, null
  br i1 %1, label %cacheIsNull, label %cont

cacheIsNull:                                      ; preds = %entry
  %2 = tail call %swift.type* @__swift_instantiateConcreteTypeFromMangledNameAbstract({ i32, i32 }* nonnull @"$sSaySSGMD") #29
  %3 = tail call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* nonnull @"$sSayxGSKsMc", %swift.type* %2, i8*** undef) #29
  store atomic i8** %3, i8*** @"$sSaySSGSayxGSKsWL" release, align 8
  br label %cont

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

; Function Attrs: mustprogress nofree noinline nounwind readonly willreturn
define linkonce_odr hidden %swift.type* @__swift_instantiateConcreteTypeFromMangledNameAbstract({ i32, i32 }* %0) local_unnamed_addr #14 {
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 !6

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) #32
  %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 #15

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

declare swiftcc void @"$ss5print_9separator10terminatoryypd_S2StF"(%Ts28__ContiguousArrayStorageBaseC*, i64, %swift.bridge*, i64, %swift.bridge*) local_unnamed_addr #0

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

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

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

declare swiftcc void @"$sSa21_makeMutableAndUniqueyyF"(%swift.type*, %TSa* nocapture swiftself dereferenceable(8)) local_unnamed_addr #0

declare swiftcc %swift.metadata_response @"$sSaMa"(i64, %swift.type*) local_unnamed_addr #0

; Function Attrs: noinline
define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNewAByxGyFSi_Tg5"(%Ts28__ContiguousArrayStorageBaseC* %0) local_unnamed_addr #13 {
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 !7
  %2 = tail call swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$ss22_ContiguousArrayBufferV20_consumeAndCreateNew14bufferIsUnique15minimumCapacity13growForAppendAByxGSb_SiSbtFSi_Tg5"(i1 false, i64 %1, i1 false, %Ts28__ContiguousArrayStorageBaseC* %0)
  ret %Ts28__ContiguousArrayStorageBaseC* %2
}

define linkonce_odr hidden swiftcc %Ts28__ContiguousArrayStorageBaseC* @"$sSa9repeating5countSayxGx_SitcfCTf4gnn_n"(%swift.opaque* noalias nocapture %0, i64 %1, %swift.type* %Element) local_unnamed_addr #0 {
entry:
  %2 = tail call swiftcc { %Ts28__ContiguousArrayStorageBaseC*, i8* } @"$sSa22_allocateUninitializedySayxG_SpyxGtSiFZ"(i64 %1, %swift.type* %Element)
  %3 = icmp slt i64 %1, 0
  br i1 %3, label %27, label %4, !prof !6

4:                                                ; preds = %entry
  %5 = extractvalue { %Ts28__ContiguousArrayStorageBaseC*, i8* } %2, 1
  %6 = icmp eq i64 %1, 0
  br i1 %6, label %.loopexit, label %.preheader

.preheader:                                       ; preds = %4
  %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 2
  %10 = bitcast i8** %9 to %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)**
  %11 = load %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)*, %swift.opaque* (%swift.opaque*, %swift.opaque*, %swift.type*)** %10, align 8, !invariant.load !9
  %12 = bitcast i8* %5 to %swift.opaque*
  %13 = tail call %swift.opaque* %11(%swift.opaque* noalias %12, %swift.opaque* noalias %0, %swift.type* %Element) #5
  %14 = icmp eq i64 %1, 1
  br i1 %14, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %.preheader
  %15 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 9
  %16 = bitcast i8** %15 to i64*
  %stride = load i64, i64* %16, align 8, !invariant.load !9
  br label %17

17:                                               ; preds = %.lr.ph, %17
  %18 = phi i64 [ 1, %.lr.ph ], [ %21, %17 ]
  %19 = phi i8* [ %5, %.lr.ph ], [ %20, %17 ]
  %20 = getelementptr inbounds i8, i8* %19, i64 %stride
  %21 = add i64 %18, 1
  %22 = bitcast i8* %20 to %swift.opaque*
  %23 = tail call %swift.opaque* %11(%swift.opaque* noalias %22, %swift.opaque* noalias %0, %swift.type* %Element) #5
  %24 = icmp eq i64 %21, %1
  br i1 %24, label %.loopexit, label %17

.loopexit:                                        ; preds = %17, %.preheader, %4
  %25 = extractvalue { %Ts28__ContiguousArrayStorageBaseC*, i8* } %2, 0
  %26 = tail call swiftcc %swift.metadata_response @"$sSaMa"(i64 0, %swift.type* %Element) #30
  ret %Ts28__ContiguousArrayStorageBaseC* %25

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

; Function Attrs: mustprogress nofree noinline nosync nounwind readnone willreturn
define hidden swiftcc %swift.metadata_response @"$s7llvm_O311FenwickTreeVMa"(i64 %0, %swift.type* readnone %1) #18 {
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_O311FenwickTreeVMn" to %swift.type_descriptor*)) #30
  ret %swift.metadata_response %3
}

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

declare swiftcc { i64, %swift.bridge* } @"$sSS7cStringSSSPys4Int8VG_tcfC"(i8*) local_unnamed_addr #0

; Function Attrs: nounwind
declare %swift.bridge* @swift_bridgeObjectRetain(%swift.bridge* returned) local_unnamed_addr #5

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

declare swiftcc i1 @"$ss27_stringCompareWithSmolCheck__9expectingSbs11_StringGutsV_ADs01_G16ComparisonResultOtF"(i64, %swift.bridge*, i64, %swift.bridge*, i8) local_unnamed_addr #0

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

; Function Attrs: nounwind
define internal swiftcc %swift.metadata_response @"$s7llvm_O311FenwickTreeVMr"(%swift.type* %"FenwickTree<Element>", i8* nocapture readnone %0, i8** nocapture readnone %1) #19 {
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) #33
  %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) #5
  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: nounwind
define internal %swift.opaque* @"$s7llvm_O311FenwickTreeVwCP"([24 x i8]* noalias %dest, [24 x i8]* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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) #28
  %63 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %53) #28
  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) #28
  ret %swift.opaque* %75
}

; Function Attrs: nounwind
define internal void @"$s7llvm_O311FenwickTreeVwxx"(%swift.opaque* noalias %object, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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) #5
  %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) #5
  %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) #5
  ret void
}

; Function Attrs: nounwind
define internal %swift.opaque* @"$s7llvm_O311FenwickTreeVwcp"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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) #28
  %50 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %41) #28
  %51 = tail call %swift.refcounted* @swift_retain(%swift.refcounted* returned %48) #28
  ret %swift.opaque* %dest
}

; Function Attrs: nounwind
define internal %swift.opaque* @"$s7llvm_O311FenwickTreeVwca"(%swift.opaque* returned %dest, %swift.opaque* %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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) #28
  tail call void @swift_release(%swift.refcounted* %33) #5
  %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) #28
  tail call void @swift_release(%swift.refcounted* %42) #5
  %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) #28
  tail call void @swift_release(%swift.refcounted* %51) #5
  ret %swift.opaque* %dest
}

; Function Attrs: nounwind
define internal %swift.opaque* @"$s7llvm_O311FenwickTreeVwtk"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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: nounwind
define internal %swift.opaque* @"$s7llvm_O311FenwickTreeVwta"(%swift.opaque* noalias returned %dest, %swift.opaque* noalias %src, %swift.type* nocapture readonly %"FenwickTree<Element>") #10 {
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) #5
  %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) #5
  %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) #5
  %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) #5
  ret %swift.opaque* %dest
}

; Function Attrs: nofree nounwind readonly
define internal i32 @"$s7llvm_O311FenwickTreeVwet"(%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 i8***
  %Element.valueWitnesses = load i8**, i8*** %3, align 8, !invariant.load !9, !dereferenceable !10
  %4 = bitcast i8** %Element.valueWitnesses to %swift.vwtable*
  %5 = getelementptr inbounds %swift.vwtable, %swift.vwtable* %4, i64 0, i32 11
  %extraInhabitantCount = load i32, i32* %5, align 4, !invariant.load !9
  %6 = tail call i32 @llvm.umax.i32(i32 %extraInhabitantCount, i32 4096)
  %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 = xor i64 %flags.alignmentMask, -1
  %11 = add nuw nsw i64 %flags.alignmentMask, 8
  %12 = and i64 %11, %10
  %13 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 8
  %14 = bitcast i8** %13 to i64*
  %size = load i64, i64* %14, align 8, !invariant.load !9
  %15 = add i64 %size, 7
  %16 = add i64 %15, %12
  %17 = and i64 %16, -8
  %18 = add i64 %17, 15
  %19 = and i64 %18, -8
  %20 = add i64 %19, 23
  %21 = and i64 %20, -8
  %size1 = add i64 %21, 16
  %22 = trunc i64 %size1 to i32
  %23 = icmp eq i32 %numEmptyCases, 0
  br i1 %23, label %found_max_xi, label %24

24:                                               ; preds = %entry
  %25 = icmp ult i32 %6, %numEmptyCases
  br i1 %25, label %26, label %.thread

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

37:                                               ; preds = %26
  %38 = load i8, i8* %36, align 1
  %39 = zext i8 %38 to i32
  br label %48

40:                                               ; preds = %26
  %41 = bitcast i8* %36 to i16*
  %42 = load i16, i16* %41, align 1
  %43 = zext i16 %42 to i32
  br label %48

44:                                               ; preds = %26
  %45 = bitcast i8* %36 to i32*
  %46 = load i32, i32* %45, align 1
  br label %48

47:                                               ; preds = %26
  unreachable

48:                                               ; preds = %44, %40, %37
  %49 = phi i32 [ %39, %37 ], [ %43, %40 ], [ %46, %44 ]
  %50 = icmp eq i32 %49, 0
  br i1 %50, label %.thread, label %51

51:                                               ; preds = %48
  %52 = add i32 %49, -1
  %53 = select i1 %27, i32 0, i32 %52
  %.not = icmp eq i32 %22, 0
  br i1 %.not, label %57, label %54

54:                                               ; preds = %51
  %55 = bitcast %swift.opaque* %value to i32*
  %56 = load i32, i32* %55, align 8
  br label %57

57:                                               ; preds = %54, %51
  %58 = phi i32 [ 0, %51 ], [ %56, %54 ]
  %59 = or i32 %58, %53
  %60 = add nuw i32 %6, 1
  %61 = add i32 %60, %59
  br label %found_max_xi

.thread:                                          ; preds = %26, %48, %24
  %62 = ptrtoint %swift.opaque* %value to i64
  %63 = add i64 %11, %62
  %64 = and i64 %63, %10
  %65 = icmp ugt i32 %extraInhabitantCount, 4095
  br i1 %65, label %66, label %is-valid-pointer

66:                                               ; preds = %.thread
  %67 = inttoptr i64 %64 to %swift.opaque*
  %68 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 6
  %69 = bitcast i8** %68 to i32 (%swift.opaque*, i32, %swift.type*)**
  %70 = load i32 (%swift.opaque*, i32, %swift.type*)*, i32 (%swift.opaque*, i32, %swift.type*)** %69, align 8, !invariant.load !9
  %71 = tail call i32 %70(%swift.opaque* noalias %67, i32 %extraInhabitantCount, %swift.type* nonnull %Element) #29
  br label %found_max_xi

is-valid-pointer:                                 ; preds = %.thread
  %72 = add i64 %15, %64
  %73 = and i64 %72, -8
  %74 = inttoptr i64 %73 to i64*
  %75 = load i64, i64* %74, align 8
  %76 = icmp ugt i64 %75, 4095
  %77 = trunc i64 %75 to i32
  %.op = add i32 %77, 1
  %78 = select i1 %76, i32 0, i32 %.op
  br label %found_max_xi

found_max_xi:                                     ; preds = %entry, %is-valid-pointer, %66, %57
  %79 = phi i32 [ %61, %57 ], [ %71, %66 ], [ %78, %is-valid-pointer ], [ 0, %entry ]
  ret i32 %79
}

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

26:                                               ; preds = %entry
  %27 = icmp ugt i32 %22, 3
  %28 = add i32 %numEmptyCases, 1
  %29 = sub i32 %28, %6
  %num-tags-phi = select i1 %27, i32 2, i32 %29
  %30 = icmp ult i32 %num-tags-phi, 2
  %31 = icmp ult i32 %num-tags-phi, 256
  %32 = icmp ult i32 %num-tags-phi, 65536
  %33 = select i1 %32, i32 2, i32 4
  %34 = select i1 %31, i32 1, i32 %33
  %num-tag-bytes = select i1 %30, i32 0, i32 %34
  br label %35

35:                                               ; preds = %26, %entry
  %36 = phi i32 [ 0, %entry ], [ %num-tag-bytes, %26 ]
  %.not = icmp ult i32 %6, %whichCase
  br i1 %.not, label %66, label %37

37:                                               ; preds = %35
  switch i32 %36, label %43 [
    i32 0, label %44
    i32 1, label %38
    i32 2, label %39
    i32 4, label %41
  ]

38:                                               ; preds = %37
  store i8 0, i8* %24, align 1
  br label %44

39:                                               ; preds = %37
  %40 = bitcast i8* %24 to i16*
  store i16 0, i16* %40, align 1
  br label %44

41:                                               ; preds = %37
  %42 = bitcast i8* %24 to i32*
  store i32 0, i32* %42, align 1
  br label %44

43:                                               ; preds = %37
  unreachable

44:                                               ; preds = %37, %41, %39, %38
  %.not9 = icmp eq i32 %whichCase, 0
  br i1 %.not9, label %found_max_xi, label %45

45:                                               ; preds = %44
  %46 = ptrtoint %swift.opaque* %value to i64
  %47 = add i64 %11, %46
  %48 = and i64 %47, %10
  %49 = icmp ugt i32 %extraInhabitantCount, 4095
  br i1 %49, label %50, label %55

50:                                               ; preds = %45
  %51 = inttoptr i64 %48 to %swift.opaque*
  %52 = getelementptr inbounds i8*, i8** %Element.valueWitnesses, i64 7
  %53 = bitcast i8** %52 to void (%swift.opaque*, i32, i32, %swift.type*)**
  %54 = load void (%swift.opaque*, i32, i32, %swift.type*)*, void (%swift.opaque*, i32, i32, %swift.type*)** %53, align 8, !invariant.load !9
  tail call void %54(%swift.opaque* noalias %51, i32 %whichCase, i32 %extraInhabitantCount, %swift.type* nonnull %Element) #5
  br label %found_max_xi

55:                                               ; preds = %45
  %56 = add i64 %15, %48
  %57 = and i64 %56, -8
  %58 = icmp ult i32 %whichCase, 4097
  %59 = inttoptr i64 %57 to i64*
  br i1 %58, label %60, label %63

60:                                               ; preds = %55
  %61 = add nsw i32 %whichCase, -1
  %62 = zext i32 %61 to i64
  store i64 %62, i64* %59, align 8
  br label %found_max_xi

63:                                               ; preds = %55
  %64 = add i32 %whichCase, -4097
  %65 = zext i32 %64 to i64
  store i64 %65, i64* %59, align 8
  br label %found_max_xi

66:                                               ; preds = %35
  %67 = icmp ugt i32 %22, 3
  %68 = sub i32 %whichCase, %6
  %spec.select = select i1 %67, i32 1, i32 %68
  %.not8 = icmp eq i32 %22, 0
  br i1 %.not8, label %73, label %69

69:                                               ; preds = %66
  %70 = xor i32 %6, -1
  %71 = add i32 %70, %whichCase
  %spec.select11 = select i1 %67, i32 %71, i32 0
  tail call void @llvm.memset.p0i8.i32(i8* align 8 %23, i8 0, i32 %22, i1 false)
  %72 = bitcast %swift.opaque* %value to i32*
  store i32 %spec.select11, i32* %72, align 8
  br label %73

73:                                               ; preds = %69, %66
  switch i32 %36, label %81 [
    i32 0, label %found_max_xi
    i32 1, label %74
    i32 2, label %76
    i32 4, label %79
  ]

74:                                               ; preds = %73
  %75 = trunc i32 %spec.select to i8
  store i8 %75, i8* %24, align 1
  br label %found_max_xi

76:                                               ; preds = %73
  %77 = trunc i32 %spec.select to i16
  %78 = bitcast i8* %24 to i16*
  store i16 %77, i16* %78, align 1
  br label %found_max_xi

79:                                               ; preds = %73
  %80 = bitcast i8* %24 to i32*
  store i32 %spec.select, i32* %80, align 1
  br label %found_max_xi

81:                                               ; preds = %73
  unreachable

found_max_xi:                                     ; preds = %63, %74, %76, %79, %73, %60, %50, %44
  ret void
}

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

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

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

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

; Function Attrs: mustprogress nofree noinline norecurse nosync nounwind readnone willreturn
define hidden swiftcc %swift.metadata_response @"$s7llvm_O32IOVMa"(i64 %0) #23 {
entry:
  ret %swift.metadata_response { %swift.type* bitcast (i64* getelementptr inbounds (<{ i8*, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32 }>* }>, <{ i8*, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32 }>* }>* @"$s7llvm_O32IOVMf", i32 0, i32 2) to %swift.type*), i64 0 }
}

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

declare swiftcc i64 @"$sSS5index6beforeSS5IndexVAD_tF"(i64, i64, %swift.bridge*) local_unnamed_addr #0

declare swiftcc { i64, %swift.bridge* } @"$sSS6remove2atSJSS5IndexV_tF"(i64, %TSS* nocapture swiftself dereferenceable(16)) local_unnamed_addr #0

declare swiftcc { i64, %swift.bridge* } @"$sSSySJSS5IndexVcig"(i64, 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 #24

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

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

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

; Function Attrs: mustprogress nofree noinline nounwind 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 #14 {
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) #29
  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 #17

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

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

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

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

attributes #0 = { "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 = { argmemonly mustprogress nofree norecurse nosync nounwind 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 #3 = { cold noreturn nounwind }
attributes #4 = { mustprogress nocallback nofree nosync nounwind readnone speculatable willreturn }
attributes #5 = { nounwind }
attributes #6 = { argmemonly mustprogress nocallback nofree nounwind willreturn }
attributes #7 = { noinline nounwind "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 #8 = { mustprogress nounwind willreturn }
attributes #9 = { mustprogress nofree norecurse nosync nounwind 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 #10 = { nounwind "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 #11 = { mustprogress nofree norecurse nosync nounwind willreturn writeonly "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 #12 = { mustprogress nofree norecurse nosync nounwind 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 #13 = { noinline "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 = { mustprogress nofree noinline nounwind 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 #15 = { argmemonly nounwind }
attributes #16 = { nofree noinline nosync nounwind 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 #17 = { nofree nounwind readonly }
attributes #18 = { mustprogress nofree noinline nosync nounwind 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 #19 = { nounwind "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 #20 = { nofree nounwind 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 = { argmemonly mustprogress nocallback nofree nounwind willreturn writeonly }
attributes #22 = { mustprogress nofree nounwind readonly willreturn }
attributes #23 = { mustprogress nofree noinline norecurse nosync nounwind 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 #24 = { 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 #25 = { 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 #26 = { nocallback nofree nosync nounwind readnone speculatable willreturn }
attributes #27 = { argmemonly nocallback nofree nounwind willreturn writeonly }
attributes #28 = { nounwind willreturn }
attributes #29 = { nounwind readonly }
attributes #30 = { nounwind readnone }
attributes #31 = { nounwind optsize }
attributes #32 = { argmemonly nounwind readonly }
attributes #33 = { 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 = !{!"branch_weights", i32 1, i32 2000}
!7 = !{i64 0, i64 9223372036854775807}
!8 = !{!"branch_weights", i32 2000, i32 1}
!9 = !{}
!10 = !{i64 96}
