brendano/profiler output.txt

## profiler output.txt
13150 samples ~ 0.4% se, though more in reality
       File                                            Function            Line
50.3 % treetm.jl cgsIterPath          383             qnewLL,pnewLL = proposePath!(newpath, mm, V,di,word, first ? nothing : oldpath, :simulate)
44.1 % treetm.jl cgsIterPath          384             qoldLL,poldLL = proposePath!(oldpath, mm, V,di,word, first ? nothing : oldpath, :evaluate)
 4.1 % treetm.jl getindex              79 getindex(c::ClassCountTable, k) = c.counts[k]
 2.1 % treetm.jl incrementFullpath!   122         x = b ? x.right : x.left
22.0 % treetm.jl proposePath!         337         w0 = (n0.counts[wordID] + betaHere/V - on0) / (n0.counts.total + betaHere - int(on_cur))
18.9 % treetm.jl proposePath!         338         w1 = (n1.counts[wordID] + betaHere/V - on1) / (n1.counts.total + betaHere - int(on_cur))
 5.2 % treetm.jl proposePath!         339         p0 = (cur_docnode.left.count + mm.gammaConc/2 - on0)
 6.5 % treetm.jl proposePath!         340         p1 = (cur_docnode.right.count+ mm.gammaConc/2 - on1)
 8.1 % treetm.jl proposePath!         341         q = p1*w1 / (p1*w1 + p0*w0)
 2.3 % treetm.jl proposePath!         344             dec = bool(rand() < q)
 1.1 % treetm.jl proposePath!         345             path[curdepth] = dec
 8.5 % treetm.jl proposePath!         350         proposalLL += dec ? log(q) : log(1-q)
11.4 % treetm.jl proposePath!         351         unnormLL += dec ? log(p1/(p0+p1)) : log(p0/(p0+p1))   # only the prior branch prob
 4.2 % treetm.jl proposePath!         367     wp = (nn.counts[wordID] + mm.betaConc/V +rem) / (nn.counts.total + mm.betaConc +rem)
 2.0 % math.jl   log                  290
100.0 % no file  anonymous             14

## treetm.jl
# vim:sw=4:sts=4

# nodeID's: one for every node in the tree. both leafs and nonleafs.
# LeafID's: one for each leaf in the tree.
# -1 indicates null

module M
include("tm.jl")

# This is a depth=2 tree, with 4 leaves, each has pathlength=2.
#
#          []
#        0   1
#       0 1 0 1
# The root's count is on a zero-length path.

type ClassCountTable
    counts::Vector{Int}
    total::Int
end

# CountTrie:  every node has a single count.
# Nothing children
type CountTrieNode
    left::Union(Nothing,CountTrieNode)
    right::Union(Nothing,CountTrieNode)
    count::Int
end
type CountTrie
    root::CountTrieNode
end
CountTrieLeaf(count::Int) = CountTrieNode(nothing,nothing,0)
CountTrieNonterm(left::CountTrieNode, right::CountTrieNode, count::Int) = CountTrieNode(left,right,count)

# ClassCountTrie: every node has a K-sized count table.
type ClassCountTrieNode
    left::Union(Nothing,ClassCountTrieNode)
    right::Union(Nothing,ClassCountTrieNode)
    counts::ClassCountTable
end
ClassCountTrieNonterm(left,right,counts) = ClassCountTrieNode(left,right,counts)
ClassCountTrieLeaf(counts) = ClassCountTrieNode(nothing,nothing,counts)
type ClassCountTrie
    root::ClassCountTrieNode
end

abstract WeightTrieNode
type WeightTrieNonterm <: WeightTrieNode
    left::WeightTrieNode
    right::WeightTrieNode
    weight::Float64
end
type WeightTrieLeaf <: WeightTrieNode
    weight::Float64
end
type WeightTrie
    root::WeightTrieNode
end


type TreeTM
    depth::Int
    gammaConc::Float64
    betaConc::Float64

    #zs::Vector{Vector{Int}}        # leaf ID's
    ypaths::Vector{Vector{BitArray{1}}}   # path format
    proposalLL::Vector{Vector{Float64}}
    unnormLL::Vector{Vector{Float64}}

    cDoc::Vector{Int}
    cDocTopic::Vector{CountTrie}
    cTopic::CountTrie
    cTopicWord::ClassCountTrie
end

###############################################

getindex(c::ClassCountTable, k) = c.counts[k]

cardinality(c::ClassCountTable) = length(c.counts)

function ClassCountTable(K)
    ct = ClassCountTable(int(zeros(K)), 0)
    ct
end

function increment!(t::ClassCountTable, k::Int, delta::Int)
    t.counts[k] += delta
    t.total += delta
end

#####  Trie-based tree count structures

###  CountTrie

function makeCountSubtrie(depth::Int)
    if depth==0
        CountTrieLeaf(0)
    else
        CountTrieNonterm(
            makeCountSubtrie(depth-1),
            makeCountSubtrie(depth-1),
            0)
    end
end

CountTrie(depth::Int) = CountTrie(makeCountSubtrie(depth))

function getCount(t::CountTrie, prefix::BitArray{1})
    x::CountTrieNode = t.root
    for b in prefix
        x = b ? x.right : x.left
    end
    x.count
end

function incrementFullpath!(t::CountTrie, fullpath::BitArray{1}, delta::Int)
    x::CountTrieNode = t.root
    x.count += delta
    for b in fullpath
        x = b ? x.right : x.left
        x.count += delta
    end
end

###  ClassCountTrie

ClassCountTrie(depth, cardinality) = ClassCountTrie(makeClassCountSubtrie(depth,cardinality))

ClassCountTrieLeaf(cardinality::Int) = ClassCountTrieLeaf(ClassCountTable(cardinality))

function makeClassCountSubtrie(depth::Int, cardinality::Int)
    if depth==0
        ClassCountTrieLeaf(cardinality)
    else
        ClassCountTrieNonterm(
            makeClassCountSubtrie(depth-1, cardinality),
            makeClassCountSubtrie(depth-1, cardinality),
            ClassCountTable(cardinality))
    end
end

ClassCountTrie(depth::Int) = ClassCountTrie(makeClassCountSubtrie(depth))

function getCount(t::ClassCountTrie, prefix::BitArray{1}, k::Int)
    x::ClassCountTrieNode = t.root
    for b in prefix
        x = b ? x.right : x.left
    end
    x.counts[k]
end

function incrementFullpath!(t::ClassCountTrie, fullpath::BitArray{1}, k::Int, delta::Int)
    x::ClassCountTrieNode = t.root
    increment!(x.counts, k, delta)
    for b in fullpath
        x = b ? x.right : x.left
        increment!(x.counts, k, delta)
    end
end

###  WeightTrie
function makeWeightSubtrie(depth::Int)
    if depth==0
        WeightTrieLeaf(0.0)
    else
        WeightTrieNonterm(
            makeWeightSubtrie(depth-1),
            makeWeightSubtrie(depth-1),
            0.0)
    end
end
WeightTrie(depth::Int) = WeightTrie(makeWeightSubtrie(depth))


### Bitstring-based tree traversals

#function treeDFS(depth::Int, f::Function)
#    _treeDFS(bitpack([]), depth, f)
#end
#
#function _treeDFS(prefix, depth, f::Function)
#    f(prefix)
#    if length(prefix) < depth
#        _treeDFS( bitpack([prefix, 0]), depth, f )
#        _treeDFS( bitpack([prefix, 1]), depth, f )
#    end
#end

function treeDFS(rootnode, depth::Int, f::Function)
    _treeDFS(bitpack([]), rootnode, depth, f)
end

function _treeDFS(prefix, node, depth, f::Function)
    f(prefix,node)
    if length(prefix) < depth
        _treeDFS( bitpack([prefix, 0]), node.left, depth, f )
        _treeDFS( bitpack([prefix, 1]), node.right, depth, f )
    end
end

bitstring(ba::BitArray{1}) = join([string(int(y)) for y in ba])

function getNode(t::ClassCountTrie, prefix::BitArray{1})
    x = t.root
    for b in prefix
        x = b? x.right : x.left
    end
    x
end

function printTopics(mm::TreeTM, vocab; numtop=10, mincount=4)
    treeDFS(mm.cTopicWord.root, mm.depth, (prefix,node) -> begin
        tot = node.counts.total
        desc = sortperm(-node.counts.counts)
        goods = find( node.counts.counts .>= mincount )
        desc = intersect(desc, goods)
        words = join(vocab[desc[1:min(end,10)]]," ")
        println("^$(bitstring(prefix))\t$(length(prefix))\t$tot\t$words")
    end
    )
end

##########################################################

function makeTTM(d::DatasetTok, depth; gammaConc=1.0,betaConc=100.0)
    V = d.numWordTypes
    #zs        = [ int(zeros(length(doc))) for doc in d.docs ]
    ypaths    = [ [bitpack(int(zeros(depth))) for i=1:length(doc)] for doc in d.docs ]
    proposalLL= [ zeros(length(doc)) for doc in d.docs]
    unnormLL  = [ zeros(length(doc)) for doc in d.docs]
    cDoc      = int([length(doc) for doc in d.docs])
    cDocTopic = [CountTrie(depth) for d in d.docs]
    cTopic    = CountTrie(depth)
    cTopicWord= ClassCountTrie(depth,V)
    TreeTM(depth, gammaConc, betaConc, ypaths, proposalLL,unnormLL,
        cDoc,cDocTopic,cTopic,cTopicWord)
end

numTopics(ss::TreeTM) = 2^ss.depth

leafPathSlow(k::Int, depth::Int) = bitpack([x-'0' for x in bits(k-1)[end-depth+1 : end]])
leafPath = leafPathSlow

function calcAllLeavesField!(weights::Vector{Float64}, depth::Int, docTopicCounts::CountTrie, conc::Float64, rem::Int = -1)
    K = length(weights)

    for k=1:K
        path = leafPath(k,depth)
        cur_node = docTopicCounts.root
        pathWeight = 1.0
        for b in path
            next_node = b ? cur_node.right : cur_node.left
            pathWeight *= (next_node.count + conc/2 + rem) / (cur_node.count + conc + rem)
            cur_node = next_node
        end
        weights[k] *= pathWeight
    end
end

function cgsIterExhaustive(mm::TreeTM, dt::DatasetTok)
    # BROKEN

    K = numTopics(mm)
    V = dt.numWordTypes

    weights = zeros(K)

    for di=1:length(dt.docs)
        for toki=1:length(dt.docs[di])
            fill!(weights, 1.0)
            calcAllLeavesField!(weights, mm.depth, mm.cDocTopic[di], mm.gammaConc)
            # multiply in lexical field
            word = dt.docs[di][toki]
            wsum = 0.0
            for k=1:K
                path = leafPath(k, mm.depth)
                num = getCount(mm.cTopicWord, path, word) + mm.betaConc/V
                den = getCount(mm.cTopic, path) + mm.betaConc
                weights[k] *= num/den
                wsum += weights[k]
            end
            oldz = mm.zs[di][toki]
            newz = discreteSample(weights, wsum)
            if oldz != newz
                mm.zs[di][toki] = newz
                newpath = leafPath(newz, mm.depth)
                incrementFullpath!(mm.cDocTopic[di], newpath, +1)
                incrementFullpath!(mm.cTopicWord, newpath, word, +1)
                incrementFullpath!(mm.cTopic, newpath, +1)
                if oldz != 0
                    oldpath = leafPath(oldz, mm.depth)
                    incrementFullpath!(mm.cDocTopic[di], oldpath, -1)
                    incrementFullpath!(mm.cTopicWord, oldpath, word, -1)
                    incrementFullpath!(mm.cTopic, oldpath, -1)
                end
            end
        end
    end
end


function pathUnnormLL(path::BitArray{1}, mm::TreeTM, V::Int, docID::Int, wordID::Int)
    # unormalized logPDF of the path under the true model, for this doc and word.
end

function proposePath!(path::BitArray{1}, mm::TreeTM, V::Int, docID::Int, wordID::Int,
            curpath::Union(Nothing,BitVector), mode)
    # draw a proposal path for this word and doc.
    # calculate the likelihood while we're at it. why not?
    # STORE path into 'path', RETURN proposal's logPMF
    # 'curpath': if our prefix is shared with the current setting, subtract one
    #   from the current counts.  If not, um, don't subtract anything.  TODO
    #   draw a picture to convince myself this is right.
    dtTree = mm.cDocTopic[docID]
    proposalLL::Float64 = 0.0
    unnormLL::Float64 = 0.0       # true unnorm prob
    cur_docnode = dtTree.root
    cur_wordnode = mm.cTopicWord.root
    on_cur = curpath != nothing
    on0::Int,on1::Int = 0,0

    for curdepth=1:mm.depth
        if on_cur
            on1 = int(curpath[curdepth])
            on0 = int(! bool(on1))
            #println("L $(bool(on0) ? "ON" : "OFF")\t$(bitstring(path[1:curdepth-1]))0")
            #println("R $(bool(on1) ? "ON" : "OFF")\t$(bitstring(path[1:curdepth-1]))1")
        end

        betaHere = 2^(mm.depth-curdepth) * mm.betaConc

        # w0,w1: p(w|y_1:l)    p0,p1: p(y_l | y_1:(l-1), d)
        n0 = cur_wordnode.left
        n1 = cur_wordnode.right
        w0 = (n0.counts[wordID] + betaHere/V - on0) / (n0.counts.total + betaHere - int(on_cur))
        w1 = (n1.counts[wordID] + betaHere/V - on1) / (n1.counts.total + betaHere - int(on_cur))
        p0 = (cur_docnode.left.count + mm.gammaConc/2 - on0)
        p1 = (cur_docnode.right.count+ mm.gammaConc/2 - on1)
        q = p1*w1 / (p1*w1 + p0*w0)

        if mode==:simulate
            dec = bool(rand() < q)
            path[curdepth] = dec
        elseif mode==:evaluate
            dec = path[curdepth]
        end

        proposalLL += dec ? log(q) : log(1-q)
        unnormLL += dec ? log(p1/(p0+p1)) : log(p0/(p0+p1))   # only the prior branch prob

        if dec
            cur_docnode = cur_docnode.right
            cur_wordnode= cur_wordnode.right
            on_cur = on_cur && bool(on1)
        else
            cur_docnode = cur_docnode.left
            cur_wordnode= cur_wordnode.left
            on_cur = on_cur && bool(on0)
        end
        on0,on1=0,0
    end
    # current node is now a leaf
    rem = 0
    nn=cur_wordnode
    wp = (nn.counts[wordID] + mm.betaConc/V +rem) / (nn.counts.total + mm.betaConc +rem)
    unnormLL += log(wp)
    return proposalLL, unnormLL
end

function cgsIterPath(mm::TreeTM, dt::DatasetTok, first::Bool)
    V = dt.numWordTypes

    newpath::BitVector = bitpack(zeros(mm.depth))
    numaccept = 0
    numdec = 0

    for di=1:length(dt.docs)
        for toki=1:length(dt.docs[di])
            word = dt.docs[di][toki]
            oldpath = mm.ypaths[di][toki]
            qnewLL,pnewLL = proposePath!(newpath, mm, V,di,word, first ? nothing : oldpath, :simulate)
            qoldLL,poldLL = proposePath!(oldpath, mm, V,di,word, first ? nothing : oldpath, :evaluate)
            logA = pnewLL-poldLL + qoldLL-qnewLL  #  (pnew-qnew) - (pold-qnew)

            #if !first
            #    @printf("A=%.3f q[%.1f -> %.1f], p[%.1f -> %.1f]\n", exp(logA), qoldLL, qnewLL, poldLL, pnewLL)
            #end

            numdec += 1
            if first || logA >= 0 || log(rand()) < logA
                # accept!
                numaccept += 1
                incrementFullpath!(mm.cDocTopic[di], newpath, +1)
                incrementFullpath!(mm.cTopicWord, newpath, word, +1)
                incrementFullpath!(mm.cTopic, newpath, +1)
                mm.proposalLL[di][toki] = qnewLL
                mm.unnormLL[di][toki] = pnewLL
                if !first
                    incrementFullpath!(mm.cDocTopic[di], oldpath, -1)
                    incrementFullpath!(mm.cTopicWord, oldpath, word, -1)
                    incrementFullpath!(mm.cTopic, oldpath, -1)
                end

                #@printf("OLD %s\nNEW %s\n\n", bitstring(oldpath), bitstring(newpath))

                # bitarray.jl:228 function copy!(dest::BitArray, src::BitArray)
                copy!(mm.ypaths[di][toki], newpath)
            end
        end
    end
    @printf("accept rate = %d/%d = %.3f\n", numaccept,numdec, numaccept/numdec)
end

end

## zz code_llvm() for proposePath!.jl
julia> code_llvm(M.proposePath!, (BitVector,M.TreeTM,Int,Int,Int,BitVector,Symbol))

define internal %jl_value_t* @"julia_proposePath!2581"(%jl_value_t*, %jl_value_t*, i64, i64, i64, %jl_value_t*, %jl_value_t*) {
top:
  %7 = alloca [23 x %jl_value_t*], align 8
  %.sub = getelementptr inbounds [23 x %jl_value_t*]* %7, i64 0, i64 0
  %8 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 2, !dbg !4573
  store %jl_value_t* inttoptr (i64 42 to %jl_value_t*), %jl_value_t** %.sub, align 8
  %9 = load %jl_value_t*** @jl_pgcstack, align 8, !dbg !4573
  %10 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 1, !dbg !4573
  %.c = bitcast %jl_value_t** %9 to %jl_value_t*, !dbg !4573
  store %jl_value_t* %.c, %jl_value_t** %10, align 8, !dbg !4573
  store %jl_value_t** %.sub, %jl_value_t*** @jl_pgcstack, align 8, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %8, align 8, !dbg !4573
  %11 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 3, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %11, align 8, !dbg !4573
  %12 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 4, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %12, align 8, !dbg !4573
  %13 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 5, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %13, align 8, !dbg !4573
  %14 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 6, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %14, align 8, !dbg !4573
  %15 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 7, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %15, align 8, !dbg !4573
  %16 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 8, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %16, align 8, !dbg !4573
  %17 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 9, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %17, align 8, !dbg !4573
  %18 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 10, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %18, align 8, !dbg !4573
  %19 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 11, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %19, align 8, !dbg !4573
  %20 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 12, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %20, align 8, !dbg !4573
  %21 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 13, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %21, align 8, !dbg !4573
  %22 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 14, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %22, align 8, !dbg !4573
  %23 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 15, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %23, align 8, !dbg !4573
  %24 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 16, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %24, align 8, !dbg !4573
  %25 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 17, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %25, align 8, !dbg !4573
  %26 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 18, !dbg !4573
  store %jl_value_t* null, %jl_value_t** %26, align 8, !dbg !4573
  %27 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 19
  store %jl_value_t* null, %jl_value_t** %27, align 8
  %28 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 20
  store %jl_value_t* null, %jl_value_t** %28, align 8
  %29 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 21
  store %jl_value_t* null, %jl_value_t** %29, align 8
  %30 = getelementptr [23 x %jl_value_t*]* %7, i64 0, i64 22
  store %jl_value_t* null, %jl_value_t** %30, align 8
  %31 = getelementptr inbounds %jl_value_t* %1, i64 8, i32 0, !dbg !4578
  %32 = load %jl_value_t** %31, align 8, !dbg !4578
  %33 = icmp eq %jl_value_t* %32, null, !dbg !4578
  br i1 %33, label %fail, label %pass, !dbg !4578

fail:                                             ; preds = %top
  %34 = load %jl_value_t** @jl_undefref_exception, align 8, !dbg !4578
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %34, i32 316), !dbg !4578
  unreachable, !dbg !4578

pass:                                             ; preds = %top
  %35 = add i64 %3, -1, !dbg !4578
  %36 = getelementptr inbounds %jl_value_t* %32, i64 2, i32 0, !dbg !4578
  %37 = load %jl_value_t** %36, align 8, !dbg !4578
  %38 = ptrtoint %jl_value_t* %37 to i64, !dbg !4578
  %39 = icmp ult i64 %35, %38, !dbg !4578
  br i1 %39, label %idxend, label %oob, !dbg !4578

oob:                                              ; preds = %pass
  %40 = load %jl_value_t** @jl_bounds_exception, align 8, !dbg !4578
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %40, i32 316), !dbg !4578
  unreachable, !dbg !4578

idxend:                                           ; preds = %pass
  %41 = getelementptr inbounds %jl_value_t* %32, i64 1, i32 0, !dbg !4578
  %42 = load %jl_value_t** %41, align 8, !dbg !4578
  %43 = getelementptr inbounds %jl_value_t* %42, i64 %35, i32 0, !dbg !4578
  %44 = load %jl_value_t** %43, align 8, !dbg !4578
  %45 = icmp eq %jl_value_t* %44, null, !dbg !4578
  br i1 %45, label %fail1, label %pass2, !dbg !4578

fail1:                                            ; preds = %idxend
  %46 = load %jl_value_t** @jl_undefref_exception, align 8, !dbg !4578
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %46, i32 316), !dbg !4578
  unreachable, !dbg !4578

pass2:                                            ; preds = %idxend
  store %jl_value_t* %44, %jl_value_t** %8, align 8, !dbg !4578
  store %jl_value_t* inttoptr (i64 4546856480 to %jl_value_t*), %jl_value_t** %11, align 8, !dbg !4579
  store %jl_value_t* inttoptr (i64 4546856480 to %jl_value_t*), %jl_value_t** %16, align 8, !dbg !4580
  %47 = getelementptr inbounds %jl_value_t* %44, i64 1, i32 0, !dbg !4581
  %48 = load %jl_value_t** %47, align 8, !dbg !4581
  %49 = icmp eq %jl_value_t* %48, null, !dbg !4581
  br i1 %49, label %fail3, label %pass4, !dbg !4581

fail3:                                            ; preds = %pass2
  %50 = load %jl_value_t** @jl_undefref_exception, align 8, !dbg !4581
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %50, i32 319), !dbg !4581
  unreachable, !dbg !4581

pass4:                                            ; preds = %pass2
  store %jl_value_t* %48, %jl_value_t** %12, align 8, !dbg !4581
  %51 = getelementptr inbounds %jl_value_t* %1, i64 10, i32 0, !dbg !4582
  %52 = load %jl_value_t** %51, align 8, !dbg !4582
  %53 = icmp eq %jl_value_t* %52, null, !dbg !4582
  br i1 %53, label %fail5, label %pass6, !dbg !4582

fail5:                                            ; preds = %pass4
  %54 = load %jl_value_t** @jl_undefref_exception, align 8, !dbg !4582
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %54, i32 320), !dbg !4582
  unreachable, !dbg !4582

pass6:                                            ; preds = %pass4
  %55 = getelementptr inbounds %jl_value_t* %52, i64 1, i32 0, !dbg !4582
  %56 = load %jl_value_t** %55, align 8, !dbg !4582
  %57 = icmp eq %jl_value_t* %56, null, !dbg !4582
  br i1 %57, label %fail7, label %pass8, !dbg !4582

fail7:                                            ; preds = %pass6
  %58 = load %jl_value_t** @jl_undefref_exception, align 8, !dbg !4582
  call void @jl_throw_with_superfluous_argument(%jl_value_t* %58, i32 320), !dbg !4582
  unreachable, !dbg !4582

pass8:                                            ; preds = %pass6
  store %jl_value_t* %56, %jl_value_t** %13, align 8, !dbg !4582
  %59 = getelementptr %jl_value_t* %1, i64 1, !dbg !4583
  %60 = bitcast %jl_value_t* %59 to i64*, !dbg !4583
  %61 = load i64* %60, align 8, !dbg !4583
  %62 = icmp slt i64 %61, 1, !dbg !4583
  br i1 %62, label %ok74, label %if.lr.ph, !dbg !4583

if.lr.ph:                                         ; preds = %pass8
  %63 = getelementptr %jl_value_t* %1, i64 3, !dbg !4584
  %64 = bitcast %jl_value_t* %63 to double*, !dbg !4584
  %65 = sitofp i64 %2 to double, !dbg !4585
  %66 = getelementptr %jl_value_t* %1, i64 2, !dbg !4586
  %67 = bitcast %jl_value_t* %66 to double*, !dbg !4586
  %magicptr = ptrtoint %jl_value_t* %6 to i64, !dbg !4587
  br label %if, !dbg !4583

if:                                               ; preds = %if.lr.ph, %L69
  %"#s125.0113" = phi i64 [ 1, %if.lr.ph ], [ %221, %L69 ]
  %on_cur.0112 = phi i1 [ true, %if.lr.ph ], [ %.82, %L69 ]
  br i1 %on_cur.0112, label %if9, label %L10, !dbg !4588

if9:                                              ; preds = %if
  %68 = call i1 @julia_getindex601(%jl_value_t* %5, i64 %"#s125.0113"), !dbg !4589
  %69 = zext i1 %68 to i64, !dbg !4589
  %70 = xor i64 %69, 1, !dbg !4590
  br label %L10, !dbg !4590

L10:                                              ; preds = %if, %if9
  %on0.1 = phi i64 [ 0, %if ], [ %70, %if9 ]
  %on1.1 = phi i64 [ 0, %if ], [ %69, %if9 ]
  %71 = load i64* %60, align 8, !dbg !4584
  %72 = sub i64 %71, %"#s125.0113", !dbg !4584
  %73 = call i64 @julia_power_by_squaring1127(i64 2, i64 %72), !dbg !4584
  %74 = load %jl_value_t** %13, align 8, !dbg !4591
  %75 = icmp eq %jl_value_t* %74, null, !dbg !4591
  br i1 %75, label %err, label %ok, !dbg !4591

err:                                              ; preds = %L10
  call void @jl_error(i8* getelementptr inbounds ([25 x i8]* @_j_str92, i64 0, i64 0)), !dbg !4591
  unreachable

ok:                                               ; preds = %L10
  %76 = load double* %64, align 8, !dbg !4584
  store %jl_value_t* %74, %jl_value_t** %27, align 8, !dbg !4591
  store %jl_value_t* inttoptr (i64 4312110096 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4591
  %77 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4591
  store %jl_value_t* %77, %jl_value_t** %17, align 8, !dbg !4591
  %78 = load %jl_value_t** %13, align 8, !dbg !4592
  %79 = icmp eq %jl_value_t* %78, null, !dbg !4592
  br i1 %79, label %err11, label %ok12, !dbg !4592

err11:                                            ; preds = %ok
  call void @jl_error(i8* getelementptr inbounds ([25 x i8]* @_j_str92, i64 0, i64 0)), !dbg !4592
  unreachable

ok12:                                             ; preds = %ok
  %80 = sitofp i64 %73 to double, !dbg !4584
  %81 = fmul double %80, %76, !dbg !4584
  store %jl_value_t* %78, %jl_value_t** %27, align 8, !dbg !4592
  store %jl_value_t* inttoptr (i64 4312110144 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4592
  %82 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4592
  store %jl_value_t* %82, %jl_value_t** %18, align 8, !dbg !4592
  store %jl_value_t* %77, %jl_value_t** %27, align 8, !dbg !4585
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4585
  %83 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4585
  store %jl_value_t* %83, %jl_value_t** %27, align 8, !dbg !4585
  %84 = call %jl_value_t* @jl_box_int64(i64 %4), !dbg !4585
  store %jl_value_t* %84, %jl_value_t** %28, align 8, !dbg !4585
  %85 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355986208 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4585
  store %jl_value_t* %85, %jl_value_t** %27, align 8, !dbg !4585
  %86 = fdiv double %81, %65, !dbg !4585
  %87 = call %jl_value_t* @alloc_2w(), !dbg !4585
  %88 = getelementptr inbounds %jl_value_t* %87, i64 0, i32 0, !dbg !4585
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %88, align 8, !dbg !4585
  %89 = getelementptr inbounds %jl_value_t* %87, i64 1, i32 0, !dbg !4585
  %90 = bitcast %jl_value_t** %89 to double*, !dbg !4585
  store double %86, double* %90, align 8, !dbg !4585
  store %jl_value_t* %87, %jl_value_t** %28, align 8, !dbg !4585
  %91 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4585
  store %jl_value_t* %91, %jl_value_t** %27, align 8, !dbg !4585
  %92 = call %jl_value_t* @jl_box_int64(i64 %on0.1), !dbg !4585
  store %jl_value_t* %92, %jl_value_t** %28, align 8, !dbg !4585
  %93 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4585
  store %jl_value_t* %93, %jl_value_t** %27, align 8, !dbg !4585
  store %jl_value_t* %77, %jl_value_t** %28, align 8, !dbg !4585
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4585
  %94 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4585
  store %jl_value_t* %94, %jl_value_t** %28, align 8, !dbg !4585
  store %jl_value_t* inttoptr (i64 4481663312 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4585
  %95 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4585
  store %jl_value_t* %95, %jl_value_t** %28, align 8, !dbg !4585
  %96 = call %jl_value_t* @alloc_2w(), !dbg !4585
  %97 = getelementptr inbounds %jl_value_t* %96, i64 0, i32 0, !dbg !4585
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %97, align 8, !dbg !4585
  %98 = getelementptr inbounds %jl_value_t* %96, i64 1, i32 0, !dbg !4585
  %99 = bitcast %jl_value_t** %98 to double*, !dbg !4585
  store double %81, double* %99, align 8, !dbg !4585
  store %jl_value_t* %96, %jl_value_t** %29, align 8, !dbg !4585
  %100 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4585
  store %jl_value_t* %100, %jl_value_t** %28, align 8, !dbg !4585
  %101 = zext i1 %on_cur.0112 to i64, !dbg !4585
  %102 = call %jl_value_t* @jl_box_int64(i64 %101), !dbg !4585
  store %jl_value_t* %102, %jl_value_t** %29, align 8, !dbg !4585
  %103 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4585
  store %jl_value_t* %103, %jl_value_t** %28, align 8, !dbg !4585
  %104 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4585
  store %jl_value_t* %104, %jl_value_t** %19, align 8, !dbg !4585
  store %jl_value_t* %82, %jl_value_t** %27, align 8, !dbg !4593
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4593
  %105 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4593
  store %jl_value_t* %105, %jl_value_t** %27, align 8, !dbg !4593
  %106 = call %jl_value_t* @jl_box_int64(i64 %4), !dbg !4593
  store %jl_value_t* %106, %jl_value_t** %28, align 8, !dbg !4593
  %107 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355986208 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4593
  store %jl_value_t* %107, %jl_value_t** %27, align 8, !dbg !4593
  %108 = call %jl_value_t* @alloc_2w(), !dbg !4593
  %109 = getelementptr inbounds %jl_value_t* %108, i64 0, i32 0, !dbg !4593
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %109, align 8, !dbg !4593
  %110 = getelementptr inbounds %jl_value_t* %108, i64 1, i32 0, !dbg !4593
  %111 = bitcast %jl_value_t** %110 to double*, !dbg !4593
  store double %86, double* %111, align 8, !dbg !4593
  store %jl_value_t* %108, %jl_value_t** %28, align 8, !dbg !4593
  %112 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4593
  store %jl_value_t* %112, %jl_value_t** %27, align 8, !dbg !4593
  %113 = call %jl_value_t* @jl_box_int64(i64 %on1.1), !dbg !4593
  store %jl_value_t* %113, %jl_value_t** %28, align 8, !dbg !4593
  %114 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4593
  store %jl_value_t* %114, %jl_value_t** %27, align 8, !dbg !4593
  store %jl_value_t* %82, %jl_value_t** %28, align 8, !dbg !4593
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4593
  %115 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4593
  store %jl_value_t* %115, %jl_value_t** %28, align 8, !dbg !4593
  store %jl_value_t* inttoptr (i64 4481663312 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4593
  %116 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4593
  store %jl_value_t* %116, %jl_value_t** %28, align 8, !dbg !4593
  %117 = call %jl_value_t* @alloc_2w(), !dbg !4593
  %118 = getelementptr inbounds %jl_value_t* %117, i64 0, i32 0, !dbg !4593
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %118, align 8, !dbg !4593
  %119 = getelementptr inbounds %jl_value_t* %117, i64 1, i32 0, !dbg !4593
  %120 = bitcast %jl_value_t** %119 to double*, !dbg !4593
  store double %81, double* %120, align 8, !dbg !4593
  store %jl_value_t* %117, %jl_value_t** %29, align 8, !dbg !4593
  %121 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4593
  store %jl_value_t* %121, %jl_value_t** %28, align 8, !dbg !4593
  %122 = call %jl_value_t* @jl_box_int64(i64 %101), !dbg !4593
  store %jl_value_t* %122, %jl_value_t** %29, align 8, !dbg !4593
  %123 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4593
  store %jl_value_t* %123, %jl_value_t** %28, align 8, !dbg !4593
  %124 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4593
  store %jl_value_t* %124, %jl_value_t** %20, align 8, !dbg !4593
  %125 = load %jl_value_t** %12, align 8, !dbg !4586
  %126 = icmp eq %jl_value_t* %125, null, !dbg !4586
  br i1 %126, label %err13, label %ok14, !dbg !4586

err13:                                            ; preds = %ok12
  call void @jl_error(i8* getelementptr inbounds ([24 x i8]* @_j_str93, i64 0, i64 0)), !dbg !4586
  unreachable

ok14:                                             ; preds = %ok12
  store %jl_value_t* %125, %jl_value_t** %27, align 8, !dbg !4586
  store %jl_value_t* inttoptr (i64 4312110096 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4586
  %127 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4586
  store %jl_value_t* %127, %jl_value_t** %27, align 8, !dbg !4586
  store %jl_value_t* inttoptr (i64 4312076784 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4586
  %128 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4586
  store %jl_value_t* %128, %jl_value_t** %27, align 8, !dbg !4586
  %129 = load double* %67, align 8, !dbg !4586
  %130 = fmul double %129, 5.000000e-01, !dbg !4586
  %131 = call %jl_value_t* @alloc_2w(), !dbg !4586
  %132 = getelementptr inbounds %jl_value_t* %131, i64 0, i32 0, !dbg !4586
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %132, align 8, !dbg !4586
  %133 = getelementptr inbounds %jl_value_t* %131, i64 1, i32 0, !dbg !4586
  %134 = bitcast %jl_value_t** %133 to double*, !dbg !4586
  store double %130, double* %134, align 8, !dbg !4586
  store %jl_value_t* %131, %jl_value_t** %28, align 8, !dbg !4586
  %135 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4586
  store %jl_value_t* %135, %jl_value_t** %27, align 8, !dbg !4586
  %136 = call %jl_value_t* @jl_box_int64(i64 %on0.1), !dbg !4586
  store %jl_value_t* %136, %jl_value_t** %28, align 8, !dbg !4586
  %137 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4586
  store %jl_value_t* %137, %jl_value_t** %21, align 8, !dbg !4586
  %138 = load %jl_value_t** %12, align 8, !dbg !4594
  %139 = icmp eq %jl_value_t* %138, null, !dbg !4594
  br i1 %139, label %err15, label %ok16, !dbg !4594

err15:                                            ; preds = %ok14
  call void @jl_error(i8* getelementptr inbounds ([24 x i8]* @_j_str93, i64 0, i64 0)), !dbg !4594
  unreachable

ok16:                                             ; preds = %ok14
  store %jl_value_t* %138, %jl_value_t** %27, align 8, !dbg !4594
  store %jl_value_t* inttoptr (i64 4312110144 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4594
  %140 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4594
  store %jl_value_t* %140, %jl_value_t** %27, align 8, !dbg !4594
  store %jl_value_t* inttoptr (i64 4312076784 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4594
  %141 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4594
  store %jl_value_t* %141, %jl_value_t** %27, align 8, !dbg !4594
  %142 = load double* %67, align 8, !dbg !4594
  %143 = fmul double %142, 5.000000e-01, !dbg !4594
  %144 = call %jl_value_t* @alloc_2w(), !dbg !4594
  %145 = getelementptr inbounds %jl_value_t* %144, i64 0, i32 0, !dbg !4594
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %145, align 8, !dbg !4594
  %146 = getelementptr inbounds %jl_value_t* %144, i64 1, i32 0, !dbg !4594
  %147 = bitcast %jl_value_t** %146 to double*, !dbg !4594
  store double %143, double* %147, align 8, !dbg !4594
  store %jl_value_t* %144, %jl_value_t** %28, align 8, !dbg !4594
  %148 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4594
  store %jl_value_t* %148, %jl_value_t** %27, align 8, !dbg !4594
  %149 = call %jl_value_t* @jl_box_int64(i64 %on1.1), !dbg !4594
  store %jl_value_t* %149, %jl_value_t** %28, align 8, !dbg !4594
  %150 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4594
  store %jl_value_t* %150, %jl_value_t** %22, align 8, !dbg !4594
  store %jl_value_t* %150, %jl_value_t** %27, align 8, !dbg !4595
  store %jl_value_t* %124, %jl_value_t** %28, align 8, !dbg !4595
  %151 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327744064 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4595
  store %jl_value_t* %151, %jl_value_t** %27, align 8, !dbg !4595
  store %jl_value_t* %150, %jl_value_t** %28, align 8, !dbg !4595
  store %jl_value_t* %124, %jl_value_t** %29, align 8, !dbg !4595
  %152 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327744064 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4595
  store %jl_value_t* %152, %jl_value_t** %28, align 8, !dbg !4595
  store %jl_value_t* %137, %jl_value_t** %29, align 8, !dbg !4595
  store %jl_value_t* %104, %jl_value_t** %30, align 8, !dbg !4595
  %153 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327744064 to %jl_value_t*), %jl_value_t** %29, i32 2), !dbg !4595
  store %jl_value_t* %153, %jl_value_t** %29, align 8, !dbg !4595
  %154 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4595
  store %jl_value_t* %154, %jl_value_t** %28, align 8, !dbg !4595
  %155 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4595
  store %jl_value_t* %155, %jl_value_t** %23, align 8, !dbg !4595
  switch i64 %magicptr, label %L22 [
    i64 4481704544, label %if17
    i64 4481704592, label %L22.thread
  ], !dbg !4587

if17:                                             ; preds = %ok16
  %156 = call double inttoptr (i64 4313792768 to double ()*)(), !dbg !4596
  %157 = call %jl_value_t* @alloc_2w(), !dbg !4596
  %158 = getelementptr inbounds %jl_value_t* %157, i64 0, i32 0, !dbg !4596
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %158, align 8, !dbg !4596
  %159 = getelementptr inbounds %jl_value_t* %157, i64 1, i32 0, !dbg !4596
  %160 = bitcast %jl_value_t** %159 to double*, !dbg !4596
  store double %156, double* %160, align 8, !dbg !4596
  store %jl_value_t* %157, %jl_value_t** %27, align 8, !dbg !4596
  store %jl_value_t* %155, %jl_value_t** %28, align 8, !dbg !4596
  %161 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4359284416 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4596
  store %jl_value_t* %161, %jl_value_t** %27, align 8, !dbg !4596
  %162 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4354988704 to %jl_value_t*), %jl_value_t** %27, i32 1), !dbg !4596
  store %jl_value_t* %162, %jl_value_t** %24, align 8, !dbg !4596
  store %jl_value_t* %0, %jl_value_t** %27, align 8, !dbg !4597
  %163 = load %jl_value_t** %24, align 8, !dbg !4597
  %164 = icmp eq %jl_value_t* %163, null, !dbg !4597
  br i1 %164, label %err18, label %ok19, !dbg !4597

err18:                                            ; preds = %if17
  call void @jl_error(i8* getelementptr inbounds ([16 x i8]* @_j_str94, i64 0, i64 0)), !dbg !4597
  unreachable

ok19:                                             ; preds = %if17
  store %jl_value_t* %163, %jl_value_t** %28, align 8, !dbg !4597
  %165 = call %jl_value_t* @jl_box_int64(i64 %"#s125.0113"), !dbg !4597
  store %jl_value_t* %165, %jl_value_t** %29, align 8, !dbg !4597
  %166 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4358804544 to %jl_value_t*), %jl_value_t** %27, i32 3), !dbg !4597
  br label %L22, !dbg !4597

L22.thread:                                       ; preds = %ok16
  %167 = call i1 @julia_getindex601(%jl_value_t* %0, i64 %"#s125.0113"), !dbg !4598
  %168 = select i1 %167, %jl_value_t* inttoptr (i64 4320351808 to %jl_value_t*), %jl_value_t* inttoptr (i64 4320351792 to %jl_value_t*), !dbg !4598
  store %jl_value_t* %168, %jl_value_t** %24, align 8, !dbg !4598
  br label %ok24, !dbg !4599

L22:                                              ; preds = %ok16, %ok19
  %.pr = load %jl_value_t** %24, align 8, !dbg !4599
  %169 = icmp eq %jl_value_t* %.pr, null, !dbg !4599
  br i1 %169, label %err23, label %ok24, !dbg !4599

err23:                                            ; preds = %L22
  call void @jl_error(i8* getelementptr inbounds ([16 x i8]* @_j_str94, i64 0, i64 0)), !dbg !4599
  unreachable

ok24:                                             ; preds = %L22.thread, %L22
  %170 = phi %jl_value_t* [ %168, %L22.thread ], [ %.pr, %L22 ]
  %171 = getelementptr inbounds %jl_value_t* %170, i64 0, i32 0, !dbg !4599
  %172 = load %jl_value_t** %171, align 8, !dbg !4599
  %173 = icmp eq %jl_value_t* %172, inttoptr (i64 4320255072 to %jl_value_t*), !dbg !4599
  br i1 %173, label %pass26, label %fail25, !dbg !4599

fail25:                                           ; preds = %ok24
  call void @jl_type_error_rt(i8* getelementptr inbounds ([13 x i8]* @_j_str95, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8]* @_j_str15, i64 0, i64 0), %jl_value_t* inttoptr (i64 4320255072 to %jl_value_t*), %jl_value_t* %170), !dbg !4599
  unreachable

pass26:                                           ; preds = %ok24
  %174 = icmp eq %jl_value_t* %170, inttoptr (i64 4320351792 to %jl_value_t*), !dbg !4599
  br i1 %174, label %L29, label %if27, !dbg !4599

if27:                                             ; preds = %pass26
  store %jl_value_t* %155, %jl_value_t** %27, align 8, !dbg !4599
  %175 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355811520 to %jl_value_t*), %jl_value_t** %27, i32 1), !dbg !4599
  br label %L30, !dbg !4599

L29:                                              ; preds = %pass26
  store %jl_value_t* inttoptr (i64 4320334944 to %jl_value_t*), %jl_value_t** %27, align 8, !dbg !4599
  store %jl_value_t* %155, %jl_value_t** %28, align 8, !dbg !4599
  %176 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327974496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4599
  store %jl_value_t* %176, %jl_value_t** %27, align 8, !dbg !4599
  %177 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355811520 to %jl_value_t*), %jl_value_t** %27, i32 1), !dbg !4599
  br label %L30, !dbg !4599

L30:                                              ; preds = %L29, %if27
  %storemerge81 = phi %jl_value_t* [ %177, %L29 ], [ %175, %if27 ]
  store %jl_value_t* %storemerge81, %jl_value_t** %25, align 8, !dbg !4599
  %178 = load %jl_value_t** inttoptr (i64 4362685504 to %jl_value_t**), align 64, !dbg !4599
  store %jl_value_t* %178, %jl_value_t** %27, align 8, !dbg !4599
  %179 = load %jl_value_t** %11, align 8, !dbg !4599
  %180 = icmp eq %jl_value_t* %179, null, !dbg !4599
  br i1 %180, label %err31, label %ok32, !dbg !4599

err31:                                            ; preds = %L30
  call void @jl_error(i8* getelementptr inbounds ([23 x i8]* @_j_str96, i64 0, i64 0)), !dbg !4599
  unreachable

ok32:                                             ; preds = %L30
  store %jl_value_t* %179, %jl_value_t** %28, align 8, !dbg !4599
  %181 = load %jl_value_t** %25, align 8, !dbg !4599
  %182 = icmp eq %jl_value_t* %181, null, !dbg !4599
  br i1 %182, label %err33, label %ok34, !dbg !4599

err33:                                            ; preds = %ok32
  call void @jl_error(i8* getelementptr inbounds ([18 x i8]* @_j_str97, i64 0, i64 0)), !dbg !4599
  unreachable

ok34:                                             ; preds = %ok32
  store %jl_value_t* %181, %jl_value_t** %29, align 8, !dbg !4599
  %183 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4599
  store %jl_value_t* %183, %jl_value_t** %28, align 8, !dbg !4599
  %184 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4358074496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4599
  store %jl_value_t* %184, %jl_value_t** %11, align 8, !dbg !4599
  %185 = load %jl_value_t** %24, align 8, !dbg !4600
  %186 = icmp eq %jl_value_t* %185, null, !dbg !4600
  br i1 %186, label %err35, label %ok36, !dbg !4600

err35:                                            ; preds = %ok34
  call void @jl_error(i8* getelementptr inbounds ([16 x i8]* @_j_str94, i64 0, i64 0)), !dbg !4600
  unreachable

ok36:                                             ; preds = %ok34
  %187 = getelementptr inbounds %jl_value_t* %185, i64 0, i32 0, !dbg !4600
  %188 = load %jl_value_t** %187, align 8, !dbg !4600
  %189 = icmp eq %jl_value_t* %188, inttoptr (i64 4320255072 to %jl_value_t*), !dbg !4600
  br i1 %189, label %pass38, label %fail37, !dbg !4600

fail37:                                           ; preds = %ok36
  call void @jl_type_error_rt(i8* getelementptr inbounds ([13 x i8]* @_j_str95, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8]* @_j_str15, i64 0, i64 0), %jl_value_t* inttoptr (i64 4320255072 to %jl_value_t*), %jl_value_t* %185), !dbg !4600
  unreachable

pass38:                                           ; preds = %ok36
  %190 = icmp eq %jl_value_t* %185, inttoptr (i64 4320351792 to %jl_value_t*), !dbg !4600
  br i1 %190, label %L41, label %if39, !dbg !4600

if39:                                             ; preds = %pass38
  store %jl_value_t* %150, %jl_value_t** %27, align 8, !dbg !4600
  store %jl_value_t* %137, %jl_value_t** %28, align 8, !dbg !4600
  store %jl_value_t* %150, %jl_value_t** %29, align 8, !dbg !4600
  %191 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4600
  store %jl_value_t* %191, %jl_value_t** %28, align 8, !dbg !4600
  %192 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4600
  store %jl_value_t* %192, %jl_value_t** %27, align 8, !dbg !4600
  %193 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355811520 to %jl_value_t*), %jl_value_t** %27, i32 1), !dbg !4600
  br label %L42, !dbg !4600

L41:                                              ; preds = %pass38
  store %jl_value_t* %137, %jl_value_t** %27, align 8, !dbg !4600
  store %jl_value_t* %137, %jl_value_t** %28, align 8, !dbg !4600
  store %jl_value_t* %150, %jl_value_t** %29, align 8, !dbg !4600
  %194 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4600
  store %jl_value_t* %194, %jl_value_t** %28, align 8, !dbg !4600
  %195 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4600
  store %jl_value_t* %195, %jl_value_t** %27, align 8, !dbg !4600
  %196 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355811520 to %jl_value_t*), %jl_value_t** %27, i32 1), !dbg !4600
  br label %L42, !dbg !4600

L42:                                              ; preds = %L41, %if39
  %storemerge = phi %jl_value_t* [ %196, %L41 ], [ %193, %if39 ]
  store %jl_value_t* %storemerge, %jl_value_t** %26, align 8, !dbg !4600
  %197 = load %jl_value_t** inttoptr (i64 4362685504 to %jl_value_t**), align 64, !dbg !4600
  store %jl_value_t* %197, %jl_value_t** %27, align 8, !dbg !4600
  %198 = load %jl_value_t** %16, align 8, !dbg !4600
  %199 = icmp eq %jl_value_t* %198, null, !dbg !4600
  br i1 %199, label %err43, label %ok44, !dbg !4600

err43:                                            ; preds = %L42
  call void @jl_error(i8* getelementptr inbounds ([21 x i8]* @_j_str98, i64 0, i64 0)), !dbg !4600
  unreachable

ok44:                                             ; preds = %L42
  store %jl_value_t* %198, %jl_value_t** %28, align 8, !dbg !4600
  %200 = load %jl_value_t** %26, align 8, !dbg !4600
  %201 = icmp eq %jl_value_t* %200, null, !dbg !4600
  br i1 %201, label %err45, label %ok46, !dbg !4600

err45:                                            ; preds = %ok44
  call void @jl_error(i8* getelementptr inbounds ([18 x i8]* @_j_str99, i64 0, i64 0)), !dbg !4600
  unreachable

ok46:                                             ; preds = %ok44
  store %jl_value_t* %200, %jl_value_t** %29, align 8, !dbg !4600
  %202 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4600
  store %jl_value_t* %202, %jl_value_t** %28, align 8, !dbg !4600
  %203 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4358074496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4600
  store %jl_value_t* %203, %jl_value_t** %16, align 8, !dbg !4600
  %204 = load %jl_value_t** %24, align 8, !dbg !4601
  %205 = icmp eq %jl_value_t* %204, null, !dbg !4601
  br i1 %205, label %err47, label %ok48, !dbg !4601

err47:                                            ; preds = %ok46
  call void @jl_error(i8* getelementptr inbounds ([16 x i8]* @_j_str94, i64 0, i64 0)), !dbg !4601
  unreachable

ok48:                                             ; preds = %ok46
  %206 = getelementptr inbounds %jl_value_t* %204, i64 0, i32 0, !dbg !4601
  %207 = load %jl_value_t** %206, align 8, !dbg !4601
  %208 = icmp eq %jl_value_t* %207, inttoptr (i64 4320255072 to %jl_value_t*), !dbg !4601
  br i1 %208, label %pass50, label %fail49, !dbg !4601

fail49:                                           ; preds = %ok48
  call void @jl_type_error_rt(i8* getelementptr inbounds ([13 x i8]* @_j_str95, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8]* @_j_str15, i64 0, i64 0), %jl_value_t* inttoptr (i64 4320255072 to %jl_value_t*), %jl_value_t* %204), !dbg !4601
  unreachable

pass50:                                           ; preds = %ok48
  %209 = icmp eq %jl_value_t* %204, inttoptr (i64 4320351792 to %jl_value_t*), !dbg !4601
  %210 = load %jl_value_t** %12, align 8, !dbg !4602
  %211 = icmp ne %jl_value_t* %210, null, !dbg !4602
  br i1 %209, label %L61, label %if51, !dbg !4601

if51:                                             ; preds = %pass50
  br i1 %211, label %ok53, label %err52, !dbg !4603

err52:                                            ; preds = %if51
  call void @jl_error(i8* getelementptr inbounds ([24 x i8]* @_j_str93, i64 0, i64 0)), !dbg !4603
  unreachable

ok53:                                             ; preds = %if51
  store %jl_value_t* %210, %jl_value_t** %27, align 8, !dbg !4603
  store %jl_value_t* inttoptr (i64 4312110144 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4603
  %212 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4603
  store %jl_value_t* %212, %jl_value_t** %12, align 8, !dbg !4603
  %213 = load %jl_value_t** %13, align 8, !dbg !4604
  %214 = icmp eq %jl_value_t* %213, null, !dbg !4604
  br i1 %214, label %err54, label %ok55, !dbg !4604

err54:                                            ; preds = %ok53
  call void @jl_error(i8* getelementptr inbounds ([25 x i8]* @_j_str92, i64 0, i64 0)), !dbg !4604
  unreachable

ok55:                                             ; preds = %ok53
  store %jl_value_t* %213, %jl_value_t** %27, align 8, !dbg !4604
  store %jl_value_t* inttoptr (i64 4312110144 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4604
  %215 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4604
  br label %L69, !dbg !4605

L61:                                              ; preds = %pass50
  br i1 %211, label %ok63, label %err62, !dbg !4602

err62:                                            ; preds = %L61
  call void @jl_error(i8* getelementptr inbounds ([24 x i8]* @_j_str93, i64 0, i64 0)), !dbg !4602
  unreachable

ok63:                                             ; preds = %L61
  store %jl_value_t* %210, %jl_value_t** %27, align 8, !dbg !4602
  store %jl_value_t* inttoptr (i64 4312110096 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4602
  %216 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4602
  store %jl_value_t* %216, %jl_value_t** %12, align 8, !dbg !4602
  %217 = load %jl_value_t** %13, align 8, !dbg !4606
  %218 = icmp eq %jl_value_t* %217, null, !dbg !4606
  br i1 %218, label %err64, label %ok65, !dbg !4606

err64:                                            ; preds = %ok63
  call void @jl_error(i8* getelementptr inbounds ([25 x i8]* @_j_str92, i64 0, i64 0)), !dbg !4606
  unreachable

ok65:                                             ; preds = %ok63
  store %jl_value_t* %217, %jl_value_t** %27, align 8, !dbg !4606
  store %jl_value_t* inttoptr (i64 4312110096 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4606
  %219 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4606
  br label %L69, !dbg !4607

L69:                                              ; preds = %ok65, %ok55
  %storemerge83 = phi %jl_value_t* [ %215, %ok55 ], [ %219, %ok65 ]
  %on0.1.sink = phi i64 [ %on1.1, %ok55 ], [ %on0.1, %ok65 ]
  store %jl_value_t* %storemerge83, %jl_value_t** %13, align 8, !dbg !4606
  %220 = icmp ne i64 %on0.1.sink, 0, !dbg !4607
  %.82 = and i1 %on_cur.0112, %220, !dbg !4607
  %221 = add i64 %"#s125.0113", 1, !dbg !4608
  %222 = icmp sgt i64 %221, %61, !dbg !4583
  br i1 %222, label %L72, label %if, !dbg !4583

L72:                                              ; preds = %L69
  %223 = phi %jl_value_t* [ %storemerge83, %L69 ]
  %224 = icmp eq %jl_value_t* %223, null, !dbg !4609
  br i1 %224, label %err73, label %ok74, !dbg !4609

err73:                                            ; preds = %L72
  call void @jl_error(i8* getelementptr inbounds ([25 x i8]* @_j_str92, i64 0, i64 0)), !dbg !4609
  unreachable

ok74:                                             ; preds = %pass8, %L72
  %225 = phi %jl_value_t* [ %223, %L72 ], [ %56, %pass8 ]
  store %jl_value_t* %225, %jl_value_t** %14, align 8, !dbg !4609
  store %jl_value_t* %225, %jl_value_t** %27, align 8, !dbg !4610
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %28, align 8, !dbg !4610
  %226 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %27, i32 2), !dbg !4610
  store %jl_value_t* %226, %jl_value_t** %27, align 8, !dbg !4610
  %227 = call %jl_value_t* @jl_box_int64(i64 %4), !dbg !4610
  store %jl_value_t* %227, %jl_value_t** %28, align 8, !dbg !4610
  %228 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355986208 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4610
  store %jl_value_t* %228, %jl_value_t** %27, align 8, !dbg !4610
  %229 = getelementptr %jl_value_t* %1, i64 3, !dbg !4610
  %230 = bitcast %jl_value_t* %229 to double*, !dbg !4610
  %231 = load double* %230, align 8, !dbg !4610
  %232 = sitofp i64 %2 to double, !dbg !4610
  %233 = fdiv double %231, %232, !dbg !4610
  %234 = call %jl_value_t* @alloc_2w(), !dbg !4610
  %235 = getelementptr inbounds %jl_value_t* %234, i64 0, i32 0, !dbg !4610
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %235, align 8, !dbg !4610
  %236 = getelementptr inbounds %jl_value_t* %234, i64 1, i32 0, !dbg !4610
  %237 = bitcast %jl_value_t** %236 to double*, !dbg !4610
  store double %233, double* %237, align 8, !dbg !4610
  store %jl_value_t* %234, %jl_value_t** %28, align 8, !dbg !4610
  %238 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4610
  store %jl_value_t* %238, %jl_value_t** %27, align 8, !dbg !4610
  %239 = call %jl_value_t* @jl_box_int64(i64 0), !dbg !4610
  store %jl_value_t* %239, %jl_value_t** %28, align 8, !dbg !4610
  %240 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4610
  store %jl_value_t* %240, %jl_value_t** %27, align 8, !dbg !4610
  store %jl_value_t* %225, %jl_value_t** %28, align 8, !dbg !4610
  store %jl_value_t* inttoptr (i64 4481691040 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4610
  %241 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4610
  store %jl_value_t* %241, %jl_value_t** %28, align 8, !dbg !4610
  store %jl_value_t* inttoptr (i64 4481663312 to %jl_value_t*), %jl_value_t** %29, align 8, !dbg !4610
  %242 = call %jl_value_t* @jl_f_get_field(%jl_value_t* null, %jl_value_t** %28, i32 2), !dbg !4610
  store %jl_value_t* %242, %jl_value_t** %28, align 8, !dbg !4610
  %243 = load double* %230, align 8, !dbg !4610
  %244 = call %jl_value_t* @alloc_2w(), !dbg !4610
  %245 = getelementptr inbounds %jl_value_t* %244, i64 0, i32 0, !dbg !4610
  store %jl_value_t* inttoptr (i64 4320257760 to %jl_value_t*), %jl_value_t** %245, align 8, !dbg !4610
  %246 = getelementptr inbounds %jl_value_t* %244, i64 1, i32 0, !dbg !4610
  %247 = bitcast %jl_value_t** %246 to double*, !dbg !4610
  store double %243, double* %247, align 8, !dbg !4610
  store %jl_value_t* %244, %jl_value_t** %29, align 8, !dbg !4610
  %248 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4610
  store %jl_value_t* %248, %jl_value_t** %28, align 8, !dbg !4610
  %249 = call %jl_value_t* @jl_box_int64(i64 0), !dbg !4610
  store %jl_value_t* %249, %jl_value_t** %29, align 8, !dbg !4610
  %250 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4610
  store %jl_value_t* %250, %jl_value_t** %28, align 8, !dbg !4610
  %251 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327970400 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4610
  store %jl_value_t* %251, %jl_value_t** %15, align 8, !dbg !4610
  %252 = load %jl_value_t** inttoptr (i64 4362685504 to %jl_value_t**), align 64, !dbg !4611
  store %jl_value_t* %252, %jl_value_t** %27, align 8, !dbg !4611
  %253 = load %jl_value_t** %16, align 8, !dbg !4611
  %254 = icmp eq %jl_value_t* %253, null, !dbg !4611
  br i1 %254, label %err75, label %ok76, !dbg !4611

err75:                                            ; preds = %ok74
  call void @jl_error(i8* getelementptr inbounds ([21 x i8]* @_j_str98, i64 0, i64 0)), !dbg !4611
  unreachable

ok76:                                             ; preds = %ok74
  store %jl_value_t* %253, %jl_value_t** %28, align 8, !dbg !4611
  store %jl_value_t* %251, %jl_value_t** %29, align 8, !dbg !4611
  %255 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4355811520 to %jl_value_t*), %jl_value_t** %29, i32 1), !dbg !4611
  store %jl_value_t* %255, %jl_value_t** %29, align 8, !dbg !4611
  %256 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4327850560 to %jl_value_t*), %jl_value_t** %28, i32 2), !dbg !4611
  store %jl_value_t* %256, %jl_value_t** %28, align 8, !dbg !4611
  %257 = call %jl_value_t* @jl_apply_generic(%jl_value_t* inttoptr (i64 4358074496 to %jl_value_t*), %jl_value_t** %27, i32 2), !dbg !4611
  store %jl_value_t* %257, %jl_value_t** %16, align 8, !dbg !4611
  %258 = load %jl_value_t** %11, align 8, !dbg !4612
  %259 = icmp eq %jl_value_t* %258, null, !dbg !4612
  br i1 %259, label %err77, label %ok78, !dbg !4612

err77:                                            ; preds = %ok76
  call void @jl_error(i8* getelementptr inbounds ([23 x i8]* @_j_str96, i64 0, i64 0)), !dbg !4612
  unreachable

ok78:                                             ; preds = %ok76
  %260 = call %jl_value_t* @allocobj(i64 32), !dbg !4612
  %261 = getelementptr inbounds %jl_value_t* %260, i64 2, i32 0, !dbg !4612
  store %jl_value_t* %258, %jl_value_t** %261, align 8, !dbg !4612
  %262 = getelementptr inbounds %jl_value_t* %260, i64 0, i32 0, !dbg !4612
  store %jl_value_t* inttoptr (i64 4320266752 to %jl_value_t*), %jl_value_t** %262, align 8, !dbg !4612
  %263 = getelementptr inbounds %jl_value_t* %260, i64 1, i32 0, !dbg !4612
  store %jl_value_t* inttoptr (i64 2 to %jl_value_t*), %jl_value_t** %263, align 8, !dbg !4612
  %264 = getelementptr inbounds %jl_value_t* %260, i64 3, i32 0, !dbg !4612
  store %jl_value_t* null, %jl_value_t** %264, align 8, !dbg !4612
  %265 = load %jl_value_t** %16, align 8, !dbg !4612
  %266 = icmp eq %jl_value_t* %265, null, !dbg !4612
  br i1 %266, label %err79, label %ok80, !dbg !4612

err79:                                            ; preds = %ok78
  call void @jl_error(i8* getelementptr inbounds ([21 x i8]* @_j_str98, i64 0, i64 0)), !dbg !4612
  unreachable

ok80:                                             ; preds = %ok78
  store %jl_value_t* %265, %jl_value_t** %264, align 8, !dbg !4612
  %267 = load %jl_value_t** %10, align 8, !dbg !4612
  %268 = getelementptr inbounds %jl_value_t* %267, i64 0, i32 0, !dbg !4612
  store %jl_value_t** %268, %jl_value_t*** @jl_pgcstack, align 8, !dbg !4612
  ret %jl_value_t* %260, !dbg !4612
}

## zz code_typed() for proposePath!.jl
julia> code_typed(M.proposePath!, (BitVector,M.TreeTM,Int,Int,Int,BitVector,Symbol))
1-element Array{Any,1}:
 :($(Expr(:lambda, {:path,:mm,:V,:docID,:wordID,:curpath,:mode}, {{:dtTree,:proposalLL,:cur_docnode,:cur_wordnode,:on_cur,:#s127,:#s126,:on0,:on1,:rem,:nn,:wp,:unnormLL,:#s125,:#s124,:curdepth,:betaHere,:n0,:n1,:w0,:w1,:p0,:p1,:q,:dec,:#s109,:#s108},{{:path,BitArray{1},0},{:mm,TreeTM,0},{:V,Int64,0},{:docID,Int64,0},{:wordID,Int64,0},{:curpath,BitArray{1},0},{:mode,Symbol,0},{:dtTree,CountTrie,18},{:proposalLL,Any,2},{:cur_docnode,Any,2},{:cur_wordnode,Any,2},{:on_cur,Bool,2},{:#s127,Int64,18},{:#s126,Int64,18},{:on0,Int64,2},{:on1,Int64,2},{:rem,Int64,18},{:nn,Any,18},{:wp,Any,18},{:unnormLL,Any,2},{:#s125,Int64,2},{:#s124,Int64,18},{:curdepth,Int64,18},{:betaHere,Float64,18},{:n0,Any,18},{:n1,Any,18},{:w0,Any,18},{:w1,Any,18},{:p0,Any,18},{:p1,Any,18},{:q,Any,18},{:dec,Any,2},{:#s109,Any,2},{:#s108,Any,2}},{}}, quote  # /Users/brendano/Desktop/hier_lda/code/treetm.jl, line 316:
        dtTree = arrayref(top(getfield)(mm::TreeTM,:cDocTopic)::Array{CountTrie,1},docID::Int64)::CountTrie # line 317:
        proposalLL = 0.0 # line 318:
        unnormLL = 0.0 # line 319:
        cur_docnode = top(getfield)(dtTree::CountTrie,:root)::CountTrieNode # line 320:
        cur_wordnode = top(getfield)(top(getfield)(mm::TreeTM,:cTopicWord)::ClassCountTrie,:root)::ClassCountTrieNode # line 321:
        on_cur = top(box)(Bool,top(not_int)(is(curpath::BitArray{1},nothing)::Bool))::Bool # line 322:
        #s127 = 0
        #s126 = 0
        on0 = #s127::Int64
        on1 = #s126::Int64 # line 324:
        #s125 = 1
        #s124 = top(getfield)(mm::TreeTM,:depth)::Int64
        1:
        unless top(sle_int)(#s125::Int64,#s124::Int64)::Bool goto 2
        curdepth = #s125::Int64 # line 325:
        unless on_cur::Bool goto 4 # line 326:
        on1 = top(box)($(Int64),top(zext_int)($(Int64),getindex(curpath::BitArray{1},curdepth::Int64)::Bool))::Int64 # line 327:
        on0 = top(box)($(Int64),top(zext_int)($(Int64),top(box)(Bool,top(not_int)(top(box)(Bool,top(not_int)(===(on1::Int64,0)::Bool))::Bool))::Bool))::Int64
        4:  # line 332:
        betaHere = top(box)(Float64,top(mul_float)(top(box)($(Float64),top(sitofp)($(Float64),top(power_by_squaring)(2,top(box)(Int64,top(sub_int)(top(getfield)(mm::TreeTM,:depth)::Int64,curdepth::Int64))::Int64)::Int64))::Float64,top(getfield)(mm::TreeTM,:betaConc)::Float64))::Float64 # line 335:
        n0 = top(getfield)(cur_wordnode,:left) # line 336:
        n1 = top(getfield)(cur_wordnode,:right) # line 337:
        w0 = /(-(+(getindex(top(getfield)(n0,:counts),wordID::Int64),top(box)(Float64,top(div_float)(betaHere::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),on0::Int64),-(+(top(getfield)(top(getfield)(n0,:counts),:total),betaHere::Float64),top(box)($(Int64),top(zext_int)($(Int64),on_cur::Bool))::Int64)) # line 338:
        w1 = /(-(+(getindex(top(getfield)(n1,:counts),wordID::Int64),top(box)(Float64,top(div_float)(betaHere::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),on1::Int64),-(+(top(getfield)(top(getfield)(n1,:counts),:total),betaHere::Float64),top(box)($(Int64),top(zext_int)($(Int64),on_cur::Bool))::Int64)) # line 339:
        p0 = -(+(top(getfield)(top(getfield)(cur_docnode,:left),:count),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:gammaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),2))::Float64))::Float64),on0::Int64) # line 340:
        p1 = -(+(top(getfield)(top(getfield)(cur_docnode,:right),:count),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:gammaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),2))::Float64))::Float64),on1::Int64) # line 341:
        q = /(*(p1,w1),+(*(p1,w1),*(p0,w0))) # line 343:
        unless is(mode::Symbol,:simulate)::Bool goto 5 # line 344:
        dec = bool(<(top(ccall)($(Expr(:call1, :(top(tuple)), "dsfmt_gv_genrand_close_open", :librandom))::(ASCIIString,Symbol),Float64,$(()))::Float64,q)) # line 345:
        setindex!(path::BitArray{1},dec,curdepth::Int64)
        goto 6
        5:  # line 346:
        unless is(mode::Symbol,:evaluate)::Bool goto 6 # line 347:
        dec = getindex(path::BitArray{1},curdepth::Int64)::Bool
        6:  # line 350:
        unless dec::Top goto 7
        #s109 = log(q)
        goto 8
        7:
        #s109 = log(-(1,q))
        8:
        proposalLL = top(convert)(Float64,+(proposalLL,#s109)) # line 351:
        unless dec::Top goto 9
        #s108 = log(/(p1,+(p0,p1)))
        goto 10
        9:
        #s108 = log(/(p0,+(p0,p1)))
        10:
        unnormLL = top(convert)(Float64,+(unnormLL,#s108)) # line 353:
        unless dec::Top goto 13 # line 354:
        cur_docnode = top(getfield)(cur_docnode,:right) # line 355:
        cur_wordnode = top(getfield)(cur_wordnode,:right) # line 356:
        unless on_cur::Bool goto 11
        on_cur = top(box)(Bool,top(not_int)(===(on1::Int64,0)::Bool))::Bool
        goto 12
        11:
        on_cur = false
        12:
        goto 15
        13:  # /Users/brendano/Desktop/hier_lda/code/treetm.jl, line 358:
        cur_docnode = top(getfield)(cur_docnode,:left) # line 359:
        cur_wordnode = top(getfield)(cur_wordnode,:left) # line 360:
        unless on_cur::Bool goto 14
        on_cur = top(box)(Bool,top(not_int)(===(on0::Int64,0)::Bool))::Bool
        goto 15
        14:
        on_cur = false
        15:  # line 362:
        on0 = 0
        on1 = 0
        3:
        #s125 = top(box)(Int64,top(add_int)(1,#s125::Int64))::Int64
        goto 1
        2:
        0:  # line 365:
        rem = 0 # line 366:
        nn = cur_wordnode # line 367:
        wp = /(+(+(getindex(top(getfield)(nn,:counts),wordID::Int64),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:betaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),rem::Int64),+(+(top(getfield)(top(getfield)(nn,:counts),:total),top(getfield)(mm::TreeTM,:betaConc)::Float64),rem::Int64)) # line 368:
        unnormLL = top(convert)(Float64,+(unnormLL,log(wp))) # line 369:
        return top(tuple)(proposalLL,unnormLL)::(Any,Any)
    end)))
	13150 samples ~ 0.4% se, though more in reality
	File Function Line
	50.3 % treetm.jl cgsIterPath 383 qnewLL,pnewLL = proposePath!(newpath, mm, V,di,word, first ? nothing : oldpath, :simulate)
	44.1 % treetm.jl cgsIterPath 384 qoldLL,poldLL = proposePath!(oldpath, mm, V,di,word, first ? nothing : oldpath, :evaluate)
	4.1 % treetm.jl getindex 79 getindex(c::ClassCountTable, k) = c.counts[k]
	2.1 % treetm.jl incrementFullpath! 122 x = b ? x.right : x.left
	22.0 % treetm.jl proposePath! 337 w0 = (n0.counts[wordID] + betaHere/V - on0) / (n0.counts.total + betaHere - int(on_cur))
	18.9 % treetm.jl proposePath! 338 w1 = (n1.counts[wordID] + betaHere/V - on1) / (n1.counts.total + betaHere - int(on_cur))
	5.2 % treetm.jl proposePath! 339 p0 = (cur_docnode.left.count + mm.gammaConc/2 - on0)
	6.5 % treetm.jl proposePath! 340 p1 = (cur_docnode.right.count+ mm.gammaConc/2 - on1)
	8.1 % treetm.jl proposePath! 341 q = p1w1 / (p1w1 + p0*w0)
	2.3 % treetm.jl proposePath! 344 dec = bool(rand() < q)
	1.1 % treetm.jl proposePath! 345 path[curdepth] = dec
	8.5 % treetm.jl proposePath! 350 proposalLL += dec ? log(q) : log(1-q)
	11.4 % treetm.jl proposePath! 351 unnormLL += dec ? log(p1/(p0+p1)) : log(p0/(p0+p1)) # only the prior branch prob
	4.2 % treetm.jl proposePath! 367 wp = (nn.counts[wordID] + mm.betaConc/V +rem) / (nn.counts.total + mm.betaConc +rem)
	2.0 % math.jl log 290
	100.0 % no file anonymous 14
	# vim:sw=4:sts=4

	# nodeID's: one for every node in the tree. both leafs and nonleafs.
	# LeafID's: one for each leaf in the tree.
	# -1 indicates null

	module M
	include("tm.jl")

	# This is a depth=2 tree, with 4 leaves, each has pathlength=2.
	#
	# []
	# 0 1
	# 0 1 0 1
	# The root's count is on a zero-length path.

	type ClassCountTable
	counts::Vector{Int}
	total::Int
	end

	# CountTrie: every node has a single count.
	# Nothing children
	type CountTrieNode
	left::Union(Nothing,CountTrieNode)
	right::Union(Nothing,CountTrieNode)
	count::Int
	end
	type CountTrie
	root::CountTrieNode
	end
	CountTrieLeaf(count::Int) = CountTrieNode(nothing,nothing,0)
	CountTrieNonterm(left::CountTrieNode, right::CountTrieNode, count::Int) = CountTrieNode(left,right,count)

	# ClassCountTrie: every node has a K-sized count table.
	type ClassCountTrieNode
	left::Union(Nothing,ClassCountTrieNode)
	right::Union(Nothing,ClassCountTrieNode)
	counts::ClassCountTable
	end
	ClassCountTrieNonterm(left,right,counts) = ClassCountTrieNode(left,right,counts)
	ClassCountTrieLeaf(counts) = ClassCountTrieNode(nothing,nothing,counts)
	type ClassCountTrie
	root::ClassCountTrieNode
	end

	abstract WeightTrieNode
	type WeightTrieNonterm <: WeightTrieNode
	left::WeightTrieNode
	right::WeightTrieNode
	weight::Float64
	end
	type WeightTrieLeaf <: WeightTrieNode
	weight::Float64
	end
	type WeightTrie
	root::WeightTrieNode
	end


	type TreeTM
	depth::Int
	gammaConc::Float64
	betaConc::Float64

	#zs::Vector{Vector{Int}} # leaf ID's
	ypaths::Vector{Vector{BitArray{1}}} # path format
	proposalLL::Vector{Vector{Float64}}
	unnormLL::Vector{Vector{Float64}}

	cDoc::Vector{Int}
	cDocTopic::Vector{CountTrie}
	cTopic::CountTrie
	cTopicWord::ClassCountTrie
	end

	###############################################

	getindex(c::ClassCountTable, k) = c.counts[k]

	cardinality(c::ClassCountTable) = length(c.counts)

	function ClassCountTable(K)
	ct = ClassCountTable(int(zeros(K)), 0)
	ct
	end

	function increment!(t::ClassCountTable, k::Int, delta::Int)
	t.counts[k] += delta
	t.total += delta
	end

	##### Trie-based tree count structures

	### CountTrie

	function makeCountSubtrie(depth::Int)
	if depth==0
	CountTrieLeaf(0)
	else
	CountTrieNonterm(
	makeCountSubtrie(depth-1),
	makeCountSubtrie(depth-1),
	0)
	end
	end

	CountTrie(depth::Int) = CountTrie(makeCountSubtrie(depth))

	function getCount(t::CountTrie, prefix::BitArray{1})
	x::CountTrieNode = t.root
	for b in prefix
	x = b ? x.right : x.left
	end
	x.count
	end

	function incrementFullpath!(t::CountTrie, fullpath::BitArray{1}, delta::Int)
	x::CountTrieNode = t.root
	x.count += delta
	for b in fullpath
	x = b ? x.right : x.left
	x.count += delta
	end
	end

	### ClassCountTrie

	ClassCountTrie(depth, cardinality) = ClassCountTrie(makeClassCountSubtrie(depth,cardinality))

	ClassCountTrieLeaf(cardinality::Int) = ClassCountTrieLeaf(ClassCountTable(cardinality))

	function makeClassCountSubtrie(depth::Int, cardinality::Int)
	if depth==0
	ClassCountTrieLeaf(cardinality)
	else
	ClassCountTrieNonterm(
	makeClassCountSubtrie(depth-1, cardinality),
	makeClassCountSubtrie(depth-1, cardinality),
	ClassCountTable(cardinality))
	end
	end

	ClassCountTrie(depth::Int) = ClassCountTrie(makeClassCountSubtrie(depth))

	function getCount(t::ClassCountTrie, prefix::BitArray{1}, k::Int)
	x::ClassCountTrieNode = t.root
	for b in prefix
	x = b ? x.right : x.left
	end
	x.counts[k]
	end

	function incrementFullpath!(t::ClassCountTrie, fullpath::BitArray{1}, k::Int, delta::Int)
	x::ClassCountTrieNode = t.root
	increment!(x.counts, k, delta)
	for b in fullpath
	x = b ? x.right : x.left
	increment!(x.counts, k, delta)
	end
	end

	### WeightTrie
	function makeWeightSubtrie(depth::Int)
	if depth==0
	WeightTrieLeaf(0.0)
	else
	WeightTrieNonterm(
	makeWeightSubtrie(depth-1),
	makeWeightSubtrie(depth-1),
	0.0)
	end
	end
	WeightTrie(depth::Int) = WeightTrie(makeWeightSubtrie(depth))


	### Bitstring-based tree traversals

	#function treeDFS(depth::Int, f::Function)
	# _treeDFS(bitpack([]), depth, f)
	#end
	#
	#function _treeDFS(prefix, depth, f::Function)
	# f(prefix)
	# if length(prefix) < depth
	# _treeDFS( bitpack([prefix, 0]), depth, f )
	# _treeDFS( bitpack([prefix, 1]), depth, f )
	# end
	#end

	function treeDFS(rootnode, depth::Int, f::Function)
	_treeDFS(bitpack([]), rootnode, depth, f)
	end

	function _treeDFS(prefix, node, depth, f::Function)
	f(prefix,node)
	if length(prefix) < depth
	_treeDFS( bitpack([prefix, 0]), node.left, depth, f )
	_treeDFS( bitpack([prefix, 1]), node.right, depth, f )
	end
	end

	bitstring(ba::BitArray{1}) = join([string(int(y)) for y in ba])

	function getNode(t::ClassCountTrie, prefix::BitArray{1})
	x = t.root
	for b in prefix
	x = b? x.right : x.left
	end
	x
	end

	function printTopics(mm::TreeTM, vocab; numtop=10, mincount=4)
	treeDFS(mm.cTopicWord.root, mm.depth, (prefix,node) -> begin
	tot = node.counts.total
	desc = sortperm(-node.counts.counts)
	goods = find( node.counts.counts .>= mincount )
	desc = intersect(desc, goods)
	words = join(vocab[desc[1:min(end,10)]]," ")
	println("^$(bitstring(prefix))\t$(length(prefix))\t$tot\t$words")
	end
	)
	end

	##########################################################

	function makeTTM(d::DatasetTok, depth; gammaConc=1.0,betaConc=100.0)
	V = d.numWordTypes
	#zs = [ int(zeros(length(doc))) for doc in d.docs ]
	ypaths = [ [bitpack(int(zeros(depth))) for i=1:length(doc)] for doc in d.docs ]
	proposalLL= [ zeros(length(doc)) for doc in d.docs]
	unnormLL = [ zeros(length(doc)) for doc in d.docs]
	cDoc = int([length(doc) for doc in d.docs])
	cDocTopic = [CountTrie(depth) for d in d.docs]
	cTopic = CountTrie(depth)
	cTopicWord= ClassCountTrie(depth,V)
	TreeTM(depth, gammaConc, betaConc, ypaths, proposalLL,unnormLL,
	cDoc,cDocTopic,cTopic,cTopicWord)
	end

	numTopics(ss::TreeTM) = 2^ss.depth

	leafPathSlow(k::Int, depth::Int) = bitpack([x-'0' for x in bits(k-1)[end-depth+1 : end]])
	leafPath = leafPathSlow

	function calcAllLeavesField!(weights::Vector{Float64}, depth::Int, docTopicCounts::CountTrie, conc::Float64, rem::Int = -1)
	K = length(weights)

	for k=1:K
	path = leafPath(k,depth)
	cur_node = docTopicCounts.root
	pathWeight = 1.0
	for b in path
	next_node = b ? cur_node.right : cur_node.left
	pathWeight *= (next_node.count + conc/2 + rem) / (cur_node.count + conc + rem)
	cur_node = next_node
	end
	weights[k] *= pathWeight
	end
	end

	function cgsIterExhaustive(mm::TreeTM, dt::DatasetTok)
	# BROKEN

	K = numTopics(mm)
	V = dt.numWordTypes

	weights = zeros(K)

	for di=1:length(dt.docs)
	for toki=1:length(dt.docs[di])
	fill!(weights, 1.0)
	calcAllLeavesField!(weights, mm.depth, mm.cDocTopic[di], mm.gammaConc)
	# multiply in lexical field
	word = dt.docs[di][toki]
	wsum = 0.0
	for k=1:K
	path = leafPath(k, mm.depth)
	num = getCount(mm.cTopicWord, path, word) + mm.betaConc/V
	den = getCount(mm.cTopic, path) + mm.betaConc
	weights[k] *= num/den
	wsum += weights[k]
	end
	oldz = mm.zs[di][toki]
	newz = discreteSample(weights, wsum)
	if oldz != newz
	mm.zs[di][toki] = newz
	newpath = leafPath(newz, mm.depth)
	incrementFullpath!(mm.cDocTopic[di], newpath, +1)
	incrementFullpath!(mm.cTopicWord, newpath, word, +1)
	incrementFullpath!(mm.cTopic, newpath, +1)
	if oldz != 0
	oldpath = leafPath(oldz, mm.depth)
	incrementFullpath!(mm.cDocTopic[di], oldpath, -1)
	incrementFullpath!(mm.cTopicWord, oldpath, word, -1)
	incrementFullpath!(mm.cTopic, oldpath, -1)
	end
	end
	end
	end
	end


	function pathUnnormLL(path::BitArray{1}, mm::TreeTM, V::Int, docID::Int, wordID::Int)
	# unormalized logPDF of the path under the true model, for this doc and word.
	end

	function proposePath!(path::BitArray{1}, mm::TreeTM, V::Int, docID::Int, wordID::Int,
	curpath::Union(Nothing,BitVector), mode)
	# draw a proposal path for this word and doc.
	# calculate the likelihood while we're at it. why not?
	# STORE path into 'path', RETURN proposal's logPMF
	# 'curpath': if our prefix is shared with the current setting, subtract one
	# from the current counts. If not, um, don't subtract anything. TODO
	# draw a picture to convince myself this is right.
	dtTree = mm.cDocTopic[docID]
	proposalLL::Float64 = 0.0
	unnormLL::Float64 = 0.0 # true unnorm prob
	cur_docnode = dtTree.root
	cur_wordnode = mm.cTopicWord.root
	on_cur = curpath != nothing
	on0::Int,on1::Int = 0,0

	for curdepth=1:mm.depth
	if on_cur
	on1 = int(curpath[curdepth])
	on0 = int(! bool(on1))
	#println("L $(bool(on0) ? "ON" : "OFF")\t$(bitstring(path[1:curdepth-1]))0")
	#println("R $(bool(on1) ? "ON" : "OFF")\t$(bitstring(path[1:curdepth-1]))1")
	end

	betaHere = 2^(mm.depth-curdepth) * mm.betaConc

	# w0,w1: p(w\|y_1:l) p0,p1: p(y_l \| y_1:(l-1), d)
	n0 = cur_wordnode.left
	n1 = cur_wordnode.right
	w0 = (n0.counts[wordID] + betaHere/V - on0) / (n0.counts.total + betaHere - int(on_cur))
	w1 = (n1.counts[wordID] + betaHere/V - on1) / (n1.counts.total + betaHere - int(on_cur))
	p0 = (cur_docnode.left.count + mm.gammaConc/2 - on0)
	p1 = (cur_docnode.right.count+ mm.gammaConc/2 - on1)
	q = p1w1 / (p1w1 + p0*w0)

	if mode==:simulate
	dec = bool(rand() < q)
	path[curdepth] = dec
	elseif mode==:evaluate
	dec = path[curdepth]
	end

	proposalLL += dec ? log(q) : log(1-q)
	unnormLL += dec ? log(p1/(p0+p1)) : log(p0/(p0+p1)) # only the prior branch prob

	if dec
	cur_docnode = cur_docnode.right
	cur_wordnode= cur_wordnode.right
	on_cur = on_cur && bool(on1)
	else
	cur_docnode = cur_docnode.left
	cur_wordnode= cur_wordnode.left
	on_cur = on_cur && bool(on0)
	end
	on0,on1=0,0
	end
	# current node is now a leaf
	rem = 0
	nn=cur_wordnode
	wp = (nn.counts[wordID] + mm.betaConc/V +rem) / (nn.counts.total + mm.betaConc +rem)
	unnormLL += log(wp)
	return proposalLL, unnormLL
	end

	function cgsIterPath(mm::TreeTM, dt::DatasetTok, first::Bool)
	V = dt.numWordTypes

	newpath::BitVector = bitpack(zeros(mm.depth))
	numaccept = 0
	numdec = 0

	for di=1:length(dt.docs)
	for toki=1:length(dt.docs[di])
	word = dt.docs[di][toki]
	oldpath = mm.ypaths[di][toki]
	qnewLL,pnewLL = proposePath!(newpath, mm, V,di,word, first ? nothing : oldpath, :simulate)
	qoldLL,poldLL = proposePath!(oldpath, mm, V,di,word, first ? nothing : oldpath, :evaluate)
	logA = pnewLL-poldLL + qoldLL-qnewLL # (pnew-qnew) - (pold-qnew)

	#if !first
	# @printf("A=%.3f q[%.1f -> %.1f], p[%.1f -> %.1f]\n", exp(logA), qoldLL, qnewLL, poldLL, pnewLL)
	#end

	numdec += 1
	if first \|\| logA >= 0 \|\| log(rand()) < logA
	# accept!
	numaccept += 1
	incrementFullpath!(mm.cDocTopic[di], newpath, +1)
	incrementFullpath!(mm.cTopicWord, newpath, word, +1)
	incrementFullpath!(mm.cTopic, newpath, +1)
	mm.proposalLL[di][toki] = qnewLL
	mm.unnormLL[di][toki] = pnewLL
	if !first
	incrementFullpath!(mm.cDocTopic[di], oldpath, -1)
	incrementFullpath!(mm.cTopicWord, oldpath, word, -1)
	incrementFullpath!(mm.cTopic, oldpath, -1)
	end

	#@printf("OLD %s\nNEW %s\n\n", bitstring(oldpath), bitstring(newpath))

	# bitarray.jl:228 function copy!(dest::BitArray, src::BitArray)
	copy!(mm.ypaths[di][toki], newpath)
	end
	end
	end
	@printf("accept rate = %d/%d = %.3f\n", numaccept,numdec, numaccept/numdec)
	end

	end
	julia> code_typed(M.proposePath!, (BitVector,M.TreeTM,Int,Int,Int,BitVector,Symbol))
	1-element Array{Any,1}:
	:($(Expr(:lambda, {:path,:mm,:V,:docID,:wordID,:curpath,:mode}, {{:dtTree,:proposalLL,:cur_docnode,:cur_wordnode,:on_cur,:#s127,:#s126,:on0,:on1,:rem,:nn,:wp,:unnormLL,:#s125,:#s124,:curdepth,:betaHere,:n0,:n1,:w0,:w1,:p0,:p1,:q,:dec,:#s109,:#s108},{{:path,BitArray{1},0},{:mm,TreeTM,0},{:V,Int64,0},{:docID,Int64,0},{:wordID,Int64,0},{:curpath,BitArray{1},0},{:mode,Symbol,0},{:dtTree,CountTrie,18},{:proposalLL,Any,2},{:cur_docnode,Any,2},{:cur_wordnode,Any,2},{:on_cur,Bool,2},{:#s127,Int64,18},{:#s126,Int64,18},{:on0,Int64,2},{:on1,Int64,2},{:rem,Int64,18},{:nn,Any,18},{:wp,Any,18},{:unnormLL,Any,2},{:#s125,Int64,2},{:#s124,Int64,18},{:curdepth,Int64,18},{:betaHere,Float64,18},{:n0,Any,18},{:n1,Any,18},{:w0,Any,18},{:w1,Any,18},{:p0,Any,18},{:p1,Any,18},{:q,Any,18},{:dec,Any,2},{:#s109,Any,2},{:#s108,Any,2}},{}}, quote # /Users/brendano/Desktop/hier_lda/code/treetm.jl, line 316:
	dtTree = arrayref(top(getfield)(mm::TreeTM,:cDocTopic)::Array{CountTrie,1},docID::Int64)::CountTrie # line 317:
	proposalLL = 0.0 # line 318:
	unnormLL = 0.0 # line 319:
	cur_docnode = top(getfield)(dtTree::CountTrie,:root)::CountTrieNode # line 320:
	cur_wordnode = top(getfield)(top(getfield)(mm::TreeTM,:cTopicWord)::ClassCountTrie,:root)::ClassCountTrieNode # line 321:
	on_cur = top(box)(Bool,top(not_int)(is(curpath::BitArray{1},nothing)::Bool))::Bool # line 322:
	#s127 = 0
	#s126 = 0
	on0 = #s127::Int64
	on1 = #s126::Int64 # line 324:
	#s125 = 1
	#s124 = top(getfield)(mm::TreeTM,:depth)::Int64
	1:
	unless top(sle_int)(#s125::Int64,#s124::Int64)::Bool goto 2
	curdepth = #s125::Int64 # line 325:
	unless on_cur::Bool goto 4 # line 326:
	on1 = top(box)($(Int64),top(zext_int)($(Int64),getindex(curpath::BitArray{1},curdepth::Int64)::Bool))::Int64 # line 327:
	on0 = top(box)($(Int64),top(zext_int)($(Int64),top(box)(Bool,top(not_int)(top(box)(Bool,top(not_int)(===(on1::Int64,0)::Bool))::Bool))::Bool))::Int64
	4: # line 332:
	betaHere = top(box)(Float64,top(mul_float)(top(box)($(Float64),top(sitofp)($(Float64),top(power_by_squaring)(2,top(box)(Int64,top(sub_int)(top(getfield)(mm::TreeTM,:depth)::Int64,curdepth::Int64))::Int64)::Int64))::Float64,top(getfield)(mm::TreeTM,:betaConc)::Float64))::Float64 # line 335:
	n0 = top(getfield)(cur_wordnode,:left) # line 336:
	n1 = top(getfield)(cur_wordnode,:right) # line 337:
	w0 = /(-(+(getindex(top(getfield)(n0,:counts),wordID::Int64),top(box)(Float64,top(div_float)(betaHere::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),on0::Int64),-(+(top(getfield)(top(getfield)(n0,:counts),:total),betaHere::Float64),top(box)($(Int64),top(zext_int)($(Int64),on_cur::Bool))::Int64)) # line 338:
	w1 = /(-(+(getindex(top(getfield)(n1,:counts),wordID::Int64),top(box)(Float64,top(div_float)(betaHere::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),on1::Int64),-(+(top(getfield)(top(getfield)(n1,:counts),:total),betaHere::Float64),top(box)($(Int64),top(zext_int)($(Int64),on_cur::Bool))::Int64)) # line 339:
	p0 = -(+(top(getfield)(top(getfield)(cur_docnode,:left),:count),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:gammaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),2))::Float64))::Float64),on0::Int64) # line 340:
	p1 = -(+(top(getfield)(top(getfield)(cur_docnode,:right),:count),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:gammaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),2))::Float64))::Float64),on1::Int64) # line 341:
	q = /((p1,w1),+((p1,w1),*(p0,w0))) # line 343:
	unless is(mode::Symbol,:simulate)::Bool goto 5 # line 344:
	dec = bool(<(top(ccall)($(Expr(:call1, :(top(tuple)), "dsfmt_gv_genrand_close_open", :librandom))::(ASCIIString,Symbol),Float64,$(()))::Float64,q)) # line 345:
	setindex!(path::BitArray{1},dec,curdepth::Int64)
	goto 6
	5: # line 346:
	unless is(mode::Symbol,:evaluate)::Bool goto 6 # line 347:
	dec = getindex(path::BitArray{1},curdepth::Int64)::Bool
	6: # line 350:
	unless dec::Top goto 7
	#s109 = log(q)
	goto 8
	7:
	#s109 = log(-(1,q))
	8:
	proposalLL = top(convert)(Float64,+(proposalLL,#s109)) # line 351:
	unless dec::Top goto 9
	#s108 = log(/(p1,+(p0,p1)))
	goto 10
	9:
	#s108 = log(/(p0,+(p0,p1)))
	10:
	unnormLL = top(convert)(Float64,+(unnormLL,#s108)) # line 353:
	unless dec::Top goto 13 # line 354:
	cur_docnode = top(getfield)(cur_docnode,:right) # line 355:
	cur_wordnode = top(getfield)(cur_wordnode,:right) # line 356:
	unless on_cur::Bool goto 11
	on_cur = top(box)(Bool,top(not_int)(===(on1::Int64,0)::Bool))::Bool
	goto 12
	11:
	on_cur = false
	12:
	goto 15
	13: # /Users/brendano/Desktop/hier_lda/code/treetm.jl, line 358:
	cur_docnode = top(getfield)(cur_docnode,:left) # line 359:
	cur_wordnode = top(getfield)(cur_wordnode,:left) # line 360:
	unless on_cur::Bool goto 14
	on_cur = top(box)(Bool,top(not_int)(===(on0::Int64,0)::Bool))::Bool
	goto 15
	14:
	on_cur = false
	15: # line 362:
	on0 = 0
	on1 = 0
	3:
	#s125 = top(box)(Int64,top(add_int)(1,#s125::Int64))::Int64
	goto 1
	2:
	0: # line 365:
	rem = 0 # line 366:
	nn = cur_wordnode # line 367:
	wp = /(+(+(getindex(top(getfield)(nn,:counts),wordID::Int64),top(box)(Float64,top(div_float)(top(getfield)(mm::TreeTM,:betaConc)::Float64,top(box)($(Float64),top(sitofp)($(Float64),V::Int64))::Float64))::Float64),rem::Int64),+(+(top(getfield)(top(getfield)(nn,:counts),:total),top(getfield)(mm::TreeTM,:betaConc)::Float64),rem::Int64)) # line 368:
	unnormLL = top(convert)(Float64,+(unnormLL,log(wp))) # line 369:
	return top(tuple)(proposalLL,unnormLL)::(Any,Any)
	end)))