gistfile1.txt

  0.000004 seconds (5 allocations: 144 bytes)
Body::Tuple{Float64,Float64,Bool}
1 ── %1   = (Base.getfield)(opt, :ratio)::Float64
│    %2   = (Base.getfield)(opt, :c)::Float64
│    %3   = (Base.getfield)(opt, :ls_max_iter)::Int64
│    %4   = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %5   = (Base.getfield)(%4, 1, false)::Float64
│    %6   = (Base.getfield)(∇f_x, :data)::Tuple{Float64,Float64}
│    %7   = (Base.getfield)(%6, 1, false)::Float64
│    %8   = (Base.mul_float)(%5, %7)::Float64
│    %9   = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %10  = (Base.getfield)(%9, 2, false)::Float64
│    %11  = (Base.getfield)(∇f_x, :data)::Tuple{Float64,Float64}
│    %12  = (Base.getfield)(%11, 2, false)::Float64
│    %13  = (Base.mul_float)(%10, %12)::Float64
│    %14  = (Base.add_float)(%8, %13)::Float64
│    %15  = (Base.neg_float)(%2)::Float64
│    %16  = (Base.mul_float)(%15, %14)::Float64
│    %17  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %18  = (Base.getfield)(%17, 1, false)::Float64
│    %19  = (Base.mul_float)(α_0, %18)::Float64
│    %20  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %21  = (Base.getfield)(%20, 2, false)::Float64
│    %22  = (Base.mul_float)(α_0, %21)::Float64
│    %23  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %24  = (Base.getfield)(%23, 1, false)::Float64
│    %25  = (Base.add_float)(%24, %19)::Float64
│    %26  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %27  = (Base.getfield)(%26, 2, false)::Float64
│    %28  = (Base.add_float)(%27, %22)::Float64
│    %29  = (Base.mul_float)(%25, %25)::Float64
│    %30  = (Base.add_float)(%29, %28)::Float64
│    %31  = (Base.sub_float)(%30, 11.0)::Float64
│    %32  = (Base.mul_float)(%31, %31)::Float64
│    %33  = (Base.mul_float)(%28, %28)::Float64
│    %34  = (Base.add_float)(%25, %33)::Float64
│    %35  = (Base.sub_float)(%34, 7.0)::Float64
│    %36  = (Base.mul_float)(%35, %35)::Float64
└─── %37  = (Base.add_float)(%32, %36)::Float64
2 ┄─ %38  = φ (#1 => _6, #9 => %50)::Float64
│    %39  = φ (#1 => 0, #9 => %49)::Int64
│    %40  = φ (#1 => %37, #9 => %71)::Float64
│    %41  = φ (#1 => false, #9 => %120)::Bool
│    %42  = (Base.not_int)(%41)::Bool
└───        goto #4 if not %42
3 ── %44  = (Base.sle_int)(%39, %3)::Bool
└───        goto #5
4 ──        nothing
5 ┄─ %47  = φ (#3 => %44, #4 => false)::Bool
└───        goto #10 if not %47
6 ── %49  = (Base.add_int)(%39, 1)::Int64
│    %50  = (Base.mul_float)(%38, %1)::Float64
│    %51  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %52  = (Base.getfield)(%51, 1, false)::Float64
│    %53  = (Base.mul_float)(%50, %52)::Float64
│    %54  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %55  = (Base.getfield)(%54, 2, false)::Float64
│    %56  = (Base.mul_float)(%50, %55)::Float64
│    %57  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %58  = (Base.getfield)(%57, 1, false)::Float64
│    %59  = (Base.add_float)(%58, %53)::Float64
│    %60  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %61  = (Base.getfield)(%60, 2, false)::Float64
│    %62  = (Base.add_float)(%61, %56)::Float64
│    %63  = (Base.mul_float)(%59, %59)::Float64
│    %64  = (Base.add_float)(%63, %62)::Float64
│    %65  = (Base.sub_float)(%64, 11.0)::Float64
│    %66  = (Base.mul_float)(%65, %65)::Float64
│    %67  = (Base.mul_float)(%62, %62)::Float64
│    %68  = (Base.add_float)(%59, %67)::Float64
│    %69  = (Base.sub_float)(%68, 7.0)::Float64
│    %70  = (Base.mul_float)(%69, %69)::Float64
│    %71  = (Base.add_float)(%66, %70)::Float64
│    %72  = (Base.sub_float)(%71, %71)::Float64
│    %73  = (Base.eq_float)(%72, 0.0)::Bool
│    %74  = (Base.and_int)(%73, true)::Bool
│    %75  = (Base.and_int)(%74, true)::Bool
└───        goto #8 if not %75
7 ── %77  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %78  = (Base.getfield)(%77, 1, true)::Float64
│    %79  = (Base.mul_float)(%78, %78)::Float64
│    %80  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %81  = (Base.getfield)(%80, 2, true)::Float64
│    %82  = (Base.add_float)(%79, %81)::Float64
│    %83  = (Base.sub_float)(%82, 11.0)::Float64
│    %84  = (Base.mul_float)(%83, %83)::Float64
│    %85  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %86  = (Base.getfield)(%85, 1, true)::Float64
│    %87  = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %88  = (Base.getfield)(%87, 2, true)::Float64
│    %89  = (Base.mul_float)(%88, %88)::Float64
│    %90  = (Base.add_float)(%86, %89)::Float64
│    %91  = (Base.sub_float)(%90, 7.0)::Float64
│    %92  = (Base.mul_float)(%91, %91)::Float64
│    %93  = (Base.add_float)(%84, %92)::Float64
│    %94  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %95  = (Base.getfield)(%94, 1, false)::Float64
│    %96  = (Base.mul_float)(%50, %95)::Float64
│    %97  = (Base.getfield)(d, :data)::Tuple{Float64,Float64}
│    %98  = (Base.getfield)(%97, 2, false)::Float64
│    %99  = (Base.mul_float)(%50, %98)::Float64
│    %100 = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %101 = (Base.getfield)(%100, 1, false)::Float64
│    %102 = (Base.add_float)(%101, %96)::Float64
│    %103 = (Base.getfield)(x, :data)::Tuple{Float64,Float64}
│    %104 = (Base.getfield)(%103, 2, false)::Float64
│    %105 = (Base.add_float)(%104, %99)::Float64
│    %106 = (Base.mul_float)(%102, %102)::Float64
│    %107 = (Base.add_float)(%106, %105)::Float64
│    %108 = (Base.sub_float)(%107, 11.0)::Float64
│    %109 = (Base.mul_float)(%108, %108)::Float64
│    %110 = (Base.mul_float)(%105, %105)::Float64
│    %111 = (Base.add_float)(%102, %110)::Float64
│    %112 = (Base.sub_float)(%111, 7.0)::Float64
│    %113 = (Base.mul_float)(%112, %112)::Float64
│    %114 = (Base.add_float)(%109, %113)::Float64
│    %115 = (Base.sub_float)(%93, %114)::Float64
│    %116 = (Base.mul_float)(%50, %16)::Float64
│    %117 = (Base.le_float)(%116, %115)::Bool
└───        goto #9
8 ──        nothing
9 ┄─ %120 = φ (#7 => %117, #8 => false)::Bool
└───        goto #2
10 ─ %122 = (Base.sle_int)(%3, %39)::Bool
└───        goto #12 if not %122
11 ─        goto #13
12 ─        nothing
13 ┄ %126 = φ (#11 => false, #12 => true)::Bool
│    %127 = (Core.tuple)(%38, %40, %126)::Tuple{Float64,Float64,Bool}
└───        return %127