Package evaluation to test LLLplus on Julia 1.14.0-DEV.2593 (15c2b67521*) started at 2026-07-03T14:52:46.771 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 15.46s ################################################################################ # Installation # Installing LLLplus... Resolving package versions... Installed LLLplus ─ v1.4.2 Updating `~/.julia/environments/v1.14/Project.toml` [142c1900] + LLLplus v1.4.2 Updating `~/.julia/environments/v1.14/Manifest.toml` [142c1900] + LLLplus v1.4.2 [56f22d72] + Artifacts v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [de0858da] + Printf v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.5+2 [4536629a] + OpenBLAS_jll v0.3.33+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Installation completed after 4.47s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 8.6 s ✓ TestEnv 1 dependency successfully precompiled in 9 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 1.5 s ✓ ANSIColoredPrinters 1.3 s ✓ StaticArraysCore 0.9 s ✓ LazilyInitializedFields 1.6 s ✓ DocStringExtensions 74.5 s ✓ AbstractTrees 56.5 s ✓ TranscodingStreams 1.1 s ✓ IOCapture ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =# Core.@doc " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" function minimalpolynomial(d, β::Td, p, verbose = false) where Td <: Number │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:527 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:528 =# │ Ti = getIntType(Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:529 =# │ B = zeros(Ti, d + 1, d + 1) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:530 =# │ for ix = 1:d + 1 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:531 =# │ B[1, ix] = floor(10 ^ p * β ^ (ix - 1)) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:532 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:533 =# │ B[2:d + 1, 1:d] = Matrix{Ti}(I, d, d) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:534 =# │ (Bp, _) = lll(B) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:535 =# │ a = Bp[2:d + 1, 1] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# │ function ff(x::Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:539 =# │ s = zero(Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:540 =# │ for ix = 1:d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:541 =# │ s += a[ix] * x ^ (ix - 1) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:542 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:543 =# │ s += x ^ d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:544 =# │ return s │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:548 =# │ f = ff(β) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:549 =# │ success = true │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:550 =# │ if abs(β / f) < 10 ^ p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:551 =# │ success = false │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:554 =# │ if verbose │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =# @printf "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =# @printf "Output:\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =# @printf " f(x) = x^%d" d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:558 =# │ for ix = d:-1:2 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =# @printf " %c %dx^%d" if a[ix] < 0 │ '-' │ else │ '+' │ end abs(a[ix]) ix - 1 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:560 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =# @printf " + %d\n" a[1] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:562 =# │ if ~success │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =# @printf "The results look off\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =# @printf " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =# @printf " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =# @printf "abs(β/f(β)) = %f\n" abs(β / f) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =# @printf " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p abs(β / f) / 10 ^ p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =# @printf " Maybe β did not have %d digits of precision.\n" p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =# @printf " or the minimal polynomial does not have degree %d.\n" d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:571 =# │ x = abs.(Bp[:, 2:var"end"])[:] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:572 =# │ aveB = sum(x) / length(x) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:573 =# │ ratio = Bp[1, 1] / aveB │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =# @printf " When succesful, we expect the ratio between the first element of\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =# @printf " the shortest vector and the average of elements in other vectors\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =# @printf " to be small or less than 1. Here the ratio was %f \n" ratio │ end │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:579 =# │ return (ff, success) │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,context,syntax_flags,name_val,meta,value,jl_source,is_toplevel_thunk,source │ [macrocall] | │ @doc :: Identifier | mod=Core │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) :: Value | │ " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" :: Value | │ [function] | │ [where] | │ [call] | │ minimalpolynomial :: Identifier | │ d :: Identifier | │ [::] | │ β :: Identifier | │ Td :: Identifier | │ p :: Identifier | │ [kw] | │ verbose :: Identifier | │ false :: Value | │ [<:] | │ Td :: Identifier | │ Number :: Identifier | │ [block] | │ [=] | │ Ti :: Identifier | │ [call] | │ getIntType :: Identifier | │ Td :: Identifier | │ [=] | │ B :: Identifier | │ [call] | │ zeros :: Identifier | │ Ti :: Identifier | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ 1 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [block] | │ [=] | │ [ref] | │ B :: Identifier | │ 1 :: Value | │ ix :: Identifier | │ [call] | │ floor :: Identifier | │ [call] | │ * :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [call] | │ ^ :: Identifier | │ β :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [=] | │ [ref] | │ B :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [call] | │ : :: Identifier | │ 1 :: Value | │ d :: Identifier | │ [call] | │ [curly] | │ Matrix :: Identifier | │ Ti :: Identifier | │ I :: Identifier | │ d :: Identifier | │ d :: Identifier | │ [=] | │ [tuple] | │ Bp :: Identifier | │ _ :: Identifier | │ [call] | │ lll :: Identifier | │ B :: Identifier | │ [=] | │ a :: Identifier | │ [ref] | │ Bp :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ 1 :: Value | │ [function] | │ [call] | │ ff :: Identifier | │ [::] | │ x :: Identifier | │ Td :: Identifier | │ [block] | │ [=] | │ s :: Identifier | │ [call] | │ zero :: Identifier | │ Td :: Identifier | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ 1 :: Value | │ d :: Identifier | │ [block] | │ [unknown_head] | │ s :: Identifier | │ [call] | │ * :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ [call] | │ ^ :: Identifier | │ x :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [unknown_head] | │ s :: Identifier | │ [call] | │ ^ :: Identifier | │ x :: Identifier | │ d :: Identifier | │ [return] | │ s :: Identifier | │ [=] | │ f :: Identifier | │ [call] | │ ff :: Identifier | │ β :: Identifier | │ [=] | │ success :: Identifier | │ true :: Value | │ [if] | │ [call] | │ < :: Identifier | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [block] | │ [=] | │ success :: Identifier | │ false :: Value | │ [if] | │ verbose :: Identifier | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) :: Value | │ "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" :: Value | │ d :: Identifier | │ β :: Identifier | │ Td :: Identifier | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) :: Value | │ "Output:\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) :: Value | │ " f(x) = x^%d" :: Value | │ d :: Identifier | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ d :: Identifier | │ -1 :: Value | │ 2 :: Value | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) :: Value | │ " %c %dx^%d" :: Value | │ [if] | │ [call] | │ < :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ 0 :: Value | │ '-' :: Value | │ '+' :: Value | │ [call] | │ abs :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) :: Value | │ " + %d\n" :: Value | │ [ref] | │ a :: Identifier | │ 1 :: Value | │ [if] | │ [call] | │ ~ :: Identifier | │ success :: Identifier | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) :: Value | │ "The results look off\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) :: Value | │ " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" :: Value | │ f :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) :: Value | │ " We expected to see abs(β/f(β)) > 10^%d, but instead saw " :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) :: Value | │ "abs(β/f(β)) = %f\n" :: Value | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) :: Value | │ " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" :: Value | │ p :: Identifier | │ [call] | │ / :: Identifier | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) :: Value | │ " Maybe β did not have %d digits of precision.\n" :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) :: Value | │ " or the minimal polynomial does not have degree %d.\n" :: Value | │ d :: Identifier | │ [=] | │ x :: Identifier | │ [ref] | │ [.] | │ abs :: Identifier | │ [tuple] | │ [ref] | │ Bp :: Identifier | │ : :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ end :: Identifier | │ : :: Identifier | │ [=] | │ aveB :: Identifier | │ [call] | │ / :: Identifier | │ [call] | │ sum :: Identifier | │ x :: Identifier | │ [call] | │ length :: Identifier | │ x :: Identifier | │ [=] | │ ratio :: Identifier | │ [call] | │ / :: Identifier | │ [ref] | │ Bp :: Identifier | │ 1 :: Value | │ 1 :: Value | │ aveB :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) :: Value | │ " When succesful, we expect the ratio between the first element of\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) :: Value | │ " the shortest vector and the average of elements in other vectors\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) :: Value | │ " to be small or less than 1. Here the ratio was %f \n" :: Value | │ ratio :: Identifier | │ [return] | │ [tuple] | │ ff :: Identifier | │ success :: Identifier | │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,context,syntax_flags,name_val,meta,value,jl_source,is_toplevel_thunk,source │ [block] | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ [if] | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ true :: Value | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ [=] | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ val :: Identifier | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ [function] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [where] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ minimalpolynomial :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [::] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [kw] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ verbose :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ false :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [<:] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Number :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ getIntType :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ B :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ zeros :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ + :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ + :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [for] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ + :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ B :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ floor :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ * :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 10 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ - :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ B :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 2 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ + :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [curly] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Matrix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ I :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [tuple] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ _ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ lll :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ B :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ a :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 2 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ + :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [function] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ff :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [::] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ s :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ zero :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [for] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [unknown_head] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ s :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ * :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ a :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ - :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [unknown_head] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ s :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [return] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ s :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ f :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ff :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ success :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ true :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [if] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ < :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ abs :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ f :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 10 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ success :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ false :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [if] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ verbose :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}, Printf.Spec{Val{'f'}}, Printf.Spec{Val{'s'}}, Printf.Spec{Val{'d'}}}}(UInt8[0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x3a, 0x0a, 0x20, 0x20, 0x64, 0x3d, 0x25, 0x64, 0x2c, 0x20, 0xce, 0xb2, 0x3d, 0x25, 0x66, 0x2c, 0x20, 0x54, 0x64, 0x3d, 0x25, 0x73, 0x2c, 0x20, 0x70, 0x3d, 0x25, 0x64, 0x0a], UnitRange{Int64}[1:12, 15:19, 22:26, 29:32, 35:35], (%.0d, %.6f, %s, %.0d), 4) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3a, 0x0a], UnitRange{Int64}[1:8], (), 0) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x66, 0x28, 0x78, 0x29, 0x20, 0x3d, 0x20, 0x78, 0x5e, 0x25, 0x64], UnitRange{Int64}[1:11, 14:13], (%.0d,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [for] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ -1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 2 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'c'}}, Printf.Spec{Val{'d'}}, Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x25, 0x63, 0x20, 0x25, 0x64, 0x78, 0x5e, 0x25, 0x64], UnitRange{Int64}[1:1, 4:4, 7:8, 11:10], (%c, %.0d, %.0d), 3) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [if] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ < :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ a :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 0 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ '-' :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ '+' :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ abs :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ a :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ - :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ix :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x2b, 0x20, 0x25, 0x64, 0x0a], UnitRange{Int64}[1:3, 6:6], (%.0d,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ a :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [if] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ~ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ success :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [block] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x20, 0x6f, 0x66, 0x66, 0x0a], UnitRange{Int64}[1:21], (), 0) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x68, 0x69, 0x67, 0x68, 0x2d, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0xce, 0xb2, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x20, 0x66, 0x28, 0xce, 0xb2, 0x29, 0xe2, 0x89, 0x88, 0x30, 0x2c, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:61, 64:64], (%.6f,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ f :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x57, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x65, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x29, 0x20, 0x3e, 0x20, 0x31, 0x30, 0x5e, 0x25, 0x64, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x73, 0x61, 0x77, 0x20], UnitRange{Int64}[1:40, 43:60], (%.0d,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x29, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:16, 19:19], (%.6f,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ abs :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ f :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}, Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x57, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x29, 0x2f, 0x31, 0x30, 0x5e, 0x70, 0x3e, 0x31, 0x2c, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x29, 0x2f, 0x31, 0x30, 0x5e, 0x25, 0x64, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:50, 53:55, 58:58], (%.0d, %.6f), 2) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ abs :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ β :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ f :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 10 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x4d, 0x61, 0x79, 0x62, 0x65, 0x20, 0xce, 0xb2, 0x20, 0x64, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x25, 0x64, 0x20, 0x64, 0x69, 0x67, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x0a], UnitRange{Int64}[1:24, 27:48], (%.0d,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ p :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x20, 0x70, 0x6f, 0x6c, 0x79, 0x6e, 0x6f, 0x6d, 0x69, 0x61, 0x6c, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x20, 0x25, 0x64, 0x2e, 0x0a], UnitRange{Int64}[1:49, 52:53], (%.0d,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ d :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ abs :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [tuple] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 2 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ end :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ : :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ aveB :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ sum :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ length :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ x :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [=] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ratio :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ / :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [ref] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ 1 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ aveB :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x20, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x66, 0x75, 0x6c, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x0a], UnitRange{Int64}[1:67], (), 0) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x65, 0x73, 0x74, 0x20, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x0a], UnitRange{Int64}[1:67], (), 0) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [.] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ format :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x31, 0x2e, 0x20, 0x48, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x77, 0x61, 0x73, 0x20, 0x25, 0x66, 0x20, 0x0a], UnitRange{Int64}[1:49, 52:53], (%.6f,), 1) :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ratio :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [return] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [tuple] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ ff :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ success :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ Base.Docs.doc! :: Value | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ LLLplus :: Value | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Base.Docs.Binding :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ LLLplus :: Value | [old,SL(GyRJCTedk5t,Base,SL(JK0dWnuqQYP,LLLplus,)),(. Base (inert @__MODULE__))], │ [inert] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc],jl_source=L47 │ minimalpolynomial :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Base.Docs.docstr :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Core.svec :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [call] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Dict{Symbol, Any} :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ :path => "/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl" :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ :linenumber => 500 :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ :module => LLLplus :: Value | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [where] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [curly] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Union :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [curly] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Any :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Any :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [curly] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Any :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Any :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Any :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [curly] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [<:] | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Td :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ Number :: Identifier | [old,SL(JK0dWnuqQYP,LLLplus,),@doc], │ [if] | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ true :: Value | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ val :: Identifier | [old,SL(GsL7e8eOaXI,Base.Docs,SL(JK0dWnuqQYP,LLLplus,)),@doc], │ │ file = "/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl" │ line = 500 └ mod = LLLplus ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# - Found unexpected binding of kind static_parameter Expression:  #₃₉/Td Containing expressions:  (= #₈₅/Td #₃₉/Td)  (= #₁₄ (call core.svec (call core.svec #₇₉/#minimalpolynomial#ff##0 #₃₉/Td) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538:0))  (= #₁₄ (call core.svec (call core.svec (function_type #₄₆/ff) #₃₉/Td) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538:0))  Detailed provenance:  #₃₉/Td  ├─ Td  │ ├─ Td  │ │ └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538  │ └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  │ └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  │ └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500  Stacktrace:  [1] _renumber(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ssa_rewrites::Dict{Int64, Int64}, slot_rewrites::Dict{Int64, Int64}, label_table::Dict{Int64, Int64}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1097  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1162  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1257  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1287  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:326  [7] top-level scope  @ ~/.julia/packages/LLLplus/wExHq/src/LLLplus.jl:38  [8] include(mod::Module, _path::String)  @ Base Base.jl:325  [9] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3303  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core boot.jl:522  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [13] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [15] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 in expression starting at /home/pkgeval/.julia/packages/LLLplus/wExHq/src/LLLplus.jl:1 in expression starting at stdin:5 ✗ LLLplus 32.3 s ✓ StructUtils 31.3 s ✓ Preferences 35.5 s ✓ RegistryInstances 20.3 s ✓ MarkdownAST 19.7 s ✓ CodecZlib 30.0 s ✓ StructUtils → StructUtilsStaticArraysCoreExt 31.6 s ✓ JLLWrappers 30.6 s ✓ PrecompileTools 31.5 s ✓ Libiconv_jll 31.6 s ✓ Git_LFS_jll 32.1 s ✓ OpenSSH_jll 31.5 s ✓ Expat_jll 357.6 s ✓ StaticArrays 68.6 s ✓ Parsers 31.9 s ✓ Git_jll 131.5 s ✓ JSON 31.2 s ✓ Git 214.4 s ✓ Documenter 25 dependencies successfully precompiled in 1373 seconds. 32 already precompiled. Precompilation completed after 1428.13s ################################################################################ # Testing # Testing LLLplus Status `/tmp/jl_4zreHB/Project.toml` [e30172f5] Documenter v1.17.0 [142c1900] LLLplus v1.4.2 [90137ffa] StaticArrays v1.9.18 [37e2e46d] LinearAlgebra v1.14.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_4zreHB/Manifest.toml` [a4c015fc] ANSIColoredPrinters v0.0.1 [1520ce14] AbstractTrees v0.4.5 [944b1d66] CodecZlib v0.7.8 [ffbed154] DocStringExtensions v0.9.5 [e30172f5] Documenter v1.17.0 [d7ba0133] Git v1.5.0 [b5f81e59] IOCapture v1.0.0 [692b3bcd] JLLWrappers v1.8.0 [682c06a0] JSON v1.6.1 [142c1900] LLLplus v1.4.2 [0e77f7df] LazilyInitializedFields v1.3.0 [d0879d2d] MarkdownAST v0.1.3 [69de0a69] Parsers v2.8.6 [aea7be01] PrecompileTools v1.3.4 [21216c6a] Preferences v1.5.2 [2792f1a3] RegistryInstances v0.1.0 [90137ffa] StaticArrays v1.9.18 [1e83bf80] StaticArraysCore v1.4.4 [ec057cc2] StructUtils v2.8.2 [3bb67fe8] TranscodingStreams v0.11.3 [2e619515] Expat_jll v2.8.1+0 [020c3dae] Git_LFS_jll v3.7.1+0 [f8c6e375] Git_jll v2.54.0+0 [94ce4f54] Libiconv_jll v1.18.0+0 [9bd350c2] OpenSSH_jll v10.3.1+0 [0dad84c5] ArgTools v1.2.0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [f43a241f] Downloads v1.7.0 [7b1f6079] FileWatching v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [b27032c2] LibCURL v1.0.0 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [ca575930] NetworkOptions v1.3.0 [44cfe95a] Pkg v1.14.0 [de0858da] Printf v1.11.0 [3fa0cd96] REPL v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [6462fe0b] Sockets v1.11.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [a4e569a6] Tar v1.10.0 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.5+2 [deac9b47] LibCURL_jll v8.21.0+0 [e37daf67] LibGit2_jll v1.9.4+0 [29816b5a] LibSSH2_jll v1.11.101+0 [14a3606d] MozillaCACerts_jll v2026.5.14 [4536629a] OpenBLAS_jll v0.3.33+0 [458c3c95] OpenSSL_jll v3.5.7+0 [efcefdf7] PCRE2_jll v10.47.0+0 [83775a58] Zlib_jll v1.3.2+0 [3161d3a3] Zstd_jll v1.5.7+1 [8e850b90] libblastrampoline_jll v5.15.0+0 [8e850ede] nghttp2_jll v1.69.0+0 [3f19e933] p7zip_jll v17.8.0+0 Testing Running tests... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =# Core.@doc " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" function minimalpolynomial(d, β::Td, p, verbose = false) where Td <: Number │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:527 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:528 =# │ Ti = getIntType(Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:529 =# │ B = zeros(Ti, d + 1, d + 1) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:530 =# │ for ix = 1:d + 1 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:531 =# │ B[1, ix] = floor(10 ^ p * β ^ (ix - 1)) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:532 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:533 =# │ B[2:d + 1, 1:d] = Matrix{Ti}(I, d, d) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:534 =# │ (Bp, _) = lll(B) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:535 =# │ a = Bp[2:d + 1, 1] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# │ function ff(x::Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:539 =# │ s = zero(Td) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:540 =# │ for ix = 1:d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:541 =# │ s += a[ix] * x ^ (ix - 1) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:542 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:543 =# │ s += x ^ d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:544 =# │ return s │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:548 =# │ f = ff(β) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:549 =# │ success = true │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:550 =# │ if abs(β / f) < 10 ^ p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:551 =# │ success = false │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:554 =# │ if verbose │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =# @printf "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =# @printf "Output:\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =# @printf " f(x) = x^%d" d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:558 =# │ for ix = d:-1:2 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =# @printf " %c %dx^%d" if a[ix] < 0 │ '-' │ else │ '+' │ end abs(a[ix]) ix - 1 │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:560 =# │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =# @printf " + %d\n" a[1] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:562 =# │ if ~success │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =# @printf "The results look off\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =# @printf " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =# @printf " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =# @printf "abs(β/f(β)) = %f\n" abs(β / f) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =# @printf " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p abs(β / f) / 10 ^ p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =# @printf " Maybe β did not have %d digits of precision.\n" p │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =# @printf " or the minimal polynomial does not have degree %d.\n" d │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:571 =# │ x = abs.(Bp[:, 2:var"end"])[:] │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:572 =# │ aveB = sum(x) / length(x) │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:573 =# │ ratio = Bp[1, 1] / aveB │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =# @printf " When succesful, we expect the ratio between the first element of\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =# @printf " the shortest vector and the average of elements in other vectors\n" │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =# │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =# @printf " to be small or less than 1. Here the ratio was %f \n" ratio │ end │ end │ #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:579 =# │ return (ff, success) │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,context,syntax_flags,name_val,meta,value,jl_source,is_toplevel_thunk,source │ [macrocall] | │ @doc :: Identifier | mod=Core │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) :: Value | │ " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" :: Value | │ [function] | │ [where] | │ [call] | │ minimalpolynomial :: Identifier | │ d :: Identifier | │ [::] | │ β :: Identifier | │ Td :: Identifier | │ p :: Identifier | │ [kw] | │ verbose :: Identifier | │ false :: Value | │ [<:] | │ Td :: Identifier | │ Number :: Identifier | │ [block] | │ [=] | │ Ti :: Identifier | │ [call] | │ getIntType :: Identifier | │ Td :: Identifier | │ [=] | │ B :: Identifier | │ [call] | │ zeros :: Identifier | │ Ti :: Identifier | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ 1 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [block] | │ [=] | │ [ref] | │ B :: Identifier | │ 1 :: Value | │ ix :: Identifier | │ [call] | │ floor :: Identifier | │ [call] | │ * :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [call] | │ ^ :: Identifier | │ β :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [=] | │ [ref] | │ B :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ [call] | │ : :: Identifier | │ 1 :: Value | │ d :: Identifier | │ [call] | │ [curly] | │ Matrix :: Identifier | │ Ti :: Identifier | │ I :: Identifier | │ d :: Identifier | │ d :: Identifier | │ [=] | │ [tuple] | │ Bp :: Identifier | │ _ :: Identifier | │ [call] | │ lll :: Identifier | │ B :: Identifier | │ [=] | │ a :: Identifier | │ [ref] | │ Bp :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ [call] | │ + :: Identifier | │ d :: Identifier | │ 1 :: Value | │ 1 :: Value | │ [function] | │ [call] | │ ff :: Identifier | │ [::] | │ x :: Identifier | │ Td :: Identifier | │ [block] | │ [=] | │ s :: Identifier | │ [call] | │ zero :: Identifier | │ Td :: Identifier | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ 1 :: Value | │ d :: Identifier | │ [block] | │ [unknown_head] | │ s :: Identifier | │ [call] | │ * :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ [call] | │ ^ :: Identifier | │ x :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [unknown_head] | │ s :: Identifier | │ [call] | │ ^ :: Identifier | │ x :: Identifier | │ d :: Identifier | │ [return] | │ s :: Identifier | │ [=] | │ f :: Identifier | │ [call] | │ ff :: Identifier | │ β :: Identifier | │ [=] | │ success :: Identifier | │ true :: Value | │ [if] | │ [call] | │ < :: Identifier | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [block] | │ [=] | │ success :: Identifier | │ false :: Value | │ [if] | │ verbose :: Identifier | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) :: Value | │ "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" :: Value | │ d :: Identifier | │ β :: Identifier | │ Td :: Identifier | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) :: Value | │ "Output:\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) :: Value | │ " f(x) = x^%d" :: Value | │ d :: Identifier | │ [for] | │ [=] | │ ix :: Identifier | │ [call] | │ : :: Identifier | │ d :: Identifier | │ -1 :: Value | │ 2 :: Value | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) :: Value | │ " %c %dx^%d" :: Value | │ [if] | │ [call] | │ < :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ 0 :: Value | │ '-' :: Value | │ '+' :: Value | │ [call] | │ abs :: Identifier | │ [ref] | │ a :: Identifier | │ ix :: Identifier | │ [call] | │ - :: Identifier | │ ix :: Identifier | │ 1 :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) :: Value | │ " + %d\n" :: Value | │ [ref] | │ a :: Identifier | │ 1 :: Value | │ [if] | │ [call] | │ ~ :: Identifier | │ success :: Identifier | │ [block] | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) :: Value | │ "The results look off\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) :: Value | │ " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" :: Value | │ f :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) :: Value | │ " We expected to see abs(β/f(β)) > 10^%d, but instead saw " :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) :: Value | │ "abs(β/f(β)) = %f\n" :: Value | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) :: Value | │ " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" :: Value | │ p :: Identifier | │ [call] | │ / :: Identifier | │ [call] | │ abs :: Identifier | │ [call] | │ / :: Identifier | │ β :: Identifier | │ f :: Identifier | │ [call] | │ ^ :: Identifier | │ 10 :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) :: Value | │ " Maybe β did not have %d digits of precision.\n" :: Value | │ p :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) :: Value | │ " or the minimal polynomial does not have degree %d.\n" :: Value | │ d :: Identifier | │ [=] | │ x :: Identifier | │ [ref] | │ [.] | │ abs :: Identifier | │ [tuple] | │ [ref] | │ Bp :: Identifier | │ : :: Identifier | │ [call] | │ : :: Identifier | │ 2 :: Value | │ end :: Identifier | │ : :: Identifier | │ [=] | │ aveB :: Identifier | │ [call] | │ / :: Identifier | │ [call] | │ sum :: Identifier | │ x :: Identifier | │ [call] | │ length :: Identifier | │ x :: Identifier | │ [=] | │ ratio :: Identifier | │ [call] | │ / :: Identifier | │ [ref] | │ Bp :: Identifier | │ 1 :: Value | │ 1 :: Value | │ aveB :: Identifier | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) :: Value | │ " When succesful, we expect the ratio between the first element of\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) :: Value | │ " the shortest vector and the average of elements in other vectors\n" :: Value | │ [macrocall] | │ @printf :: Identifier | │ :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) :: Value | │ " to be small or less than 1. Here the ratio was %f \n" :: Value | │ ratio :: Identifier | │ [return] | │ [tuple] | │ ff :: Identifier | │ success :: Identifier | │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,context,syntax_flags,name_val,meta,value,jl_source,is_toplevel_thunk,source │ [block] | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ [if] | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ true :: Value | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ [=] | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ val :: Identifier | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ [function] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [where] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ minimalpolynomial :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [::] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [kw] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ verbose :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ false :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [<:] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Number :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ getIntType :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ B :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ zeros :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ + :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ + :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [for] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ + :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ B :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ floor :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ * :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 10 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ - :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ B :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 2 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ + :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [curly] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Matrix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Ti :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ I :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [tuple] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ _ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ lll :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ B :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ a :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 2 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ + :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [function] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ff :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [::] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ s :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ zero :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [for] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [unknown_head] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ s :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ * :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ a :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ - :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [unknown_head] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ s :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [return] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ s :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ f :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ff :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ success :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ true :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [if] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ < :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ abs :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ f :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 10 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ success :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ false :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [if] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ verbose :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}, Printf.Spec{Val{'f'}}, Printf.Spec{Val{'s'}}, Printf.Spec{Val{'d'}}}}(UInt8[0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x3a, 0x0a, 0x20, 0x20, 0x64, 0x3d, 0x25, 0x64, 0x2c, 0x20, 0xce, 0xb2, 0x3d, 0x25, 0x66, 0x2c, 0x20, 0x54, 0x64, 0x3d, 0x25, 0x73, 0x2c, 0x20, 0x70, 0x3d, 0x25, 0x64, 0x0a], UnitRange{Int64}[1:12, 15:19, 22:26, 29:32, 35:35], (%.0d, %.6f, %s, %.0d), 4) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3a, 0x0a], UnitRange{Int64}[1:8], (), 0) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x66, 0x28, 0x78, 0x29, 0x20, 0x3d, 0x20, 0x78, 0x5e, 0x25, 0x64], UnitRange{Int64}[1:11, 14:13], (%.0d,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [for] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ -1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 2 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'c'}}, Printf.Spec{Val{'d'}}, Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x25, 0x63, 0x20, 0x25, 0x64, 0x78, 0x5e, 0x25, 0x64], UnitRange{Int64}[1:1, 4:4, 7:8, 11:10], (%c, %.0d, %.0d), 3) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [if] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ < :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ a :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 0 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ '-' :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ '+' :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ abs :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ a :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ - :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ix :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x2b, 0x20, 0x25, 0x64, 0x0a], UnitRange{Int64}[1:3, 6:6], (%.0d,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ a :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [if] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ~ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ success :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [block] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x20, 0x6f, 0x66, 0x66, 0x0a], UnitRange{Int64}[1:21], (), 0) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x68, 0x69, 0x67, 0x68, 0x2d, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0xce, 0xb2, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x20, 0x66, 0x28, 0xce, 0xb2, 0x29, 0xe2, 0x89, 0x88, 0x30, 0x2c, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:61, 64:64], (%.6f,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ f :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x57, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x65, 0x65, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x29, 0x20, 0x3e, 0x20, 0x31, 0x30, 0x5e, 0x25, 0x64, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x73, 0x61, 0x77, 0x20], UnitRange{Int64}[1:40, 43:60], (%.0d,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x28, 0xce, 0xb2, 0x29, 0x29, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:16, 19:19], (%.6f,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ abs :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ f :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}, Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x57, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x29, 0x2f, 0x31, 0x30, 0x5e, 0x70, 0x3e, 0x31, 0x2c, 0x20, 0x68, 0x65, 0x72, 0x65, 0x20, 0x61, 0x62, 0x73, 0x28, 0xce, 0xb2, 0x2f, 0x66, 0x29, 0x2f, 0x31, 0x30, 0x5e, 0x25, 0x64, 0x20, 0x3d, 0x20, 0x25, 0x66, 0x0a], UnitRange{Int64}[1:50, 53:55, 58:58], (%.0d, %.6f), 2) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ abs :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ β :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ f :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ^ :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 10 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x4d, 0x61, 0x79, 0x62, 0x65, 0x20, 0xce, 0xb2, 0x20, 0x64, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x25, 0x64, 0x20, 0x64, 0x69, 0x67, 0x69, 0x74, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x0a], UnitRange{Int64}[1:24, 27:48], (%.0d,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ p :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'d'}}}}(UInt8[0x20, 0x20, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x20, 0x70, 0x6f, 0x6c, 0x79, 0x6e, 0x6f, 0x6d, 0x69, 0x61, 0x6c, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x20, 0x25, 0x64, 0x2e, 0x0a], UnitRange{Int64}[1:49, 52:53], (%.0d,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ d :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ abs :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [tuple] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 2 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ end :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ : :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ aveB :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ sum :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ length :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ x :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [=] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ratio :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ / :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [ref] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Bp :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ 1 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ aveB :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x20, 0x20, 0x57, 0x68, 0x65, 0x6e, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x66, 0x75, 0x6c, 0x2c, 0x20, 0x77, 0x65, 0x20, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x0a], UnitRange{Int64}[1:67], (), 0) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}(UInt8[0x20, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x65, 0x73, 0x74, 0x20, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x0a], UnitRange{Int64}[1:67], (), 0) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [.] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ format :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ stdout :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{Printf.Spec{Val{'f'}}}}(UInt8[0x20, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x72, 0x20, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x20, 0x31, 0x2e, 0x20, 0x48, 0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x20, 0x77, 0x61, 0x73, 0x20, 0x25, 0x66, 0x20, 0x0a], UnitRange{Int64}[1:49, 52:53], (%.6f,), 1) :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ratio :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [return] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [tuple] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ ff :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ success :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ Base.Docs.doc! :: Value | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ LLLplus :: Value | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Base.Docs.Binding :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ LLLplus :: Value | [old,SL(7Sojmz5Ru6p,Base,SL(9bPiqlNJo5q,LLLplus,)),(. Base (inert @__MODULE__))], │ [inert] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc],jl_source=L47 │ minimalpolynomial :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Base.Docs.docstr :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Core.svec :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [call] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Dict{Symbol, Any} :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ :path => "/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl" :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ :linenumber => 500 :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ :module => LLLplus :: Value | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [where] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [curly] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Union :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [curly] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Any :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Any :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [curly] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Any :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Any :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Any :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [curly] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Tuple :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [<:] | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Td :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ Number :: Identifier | [old,SL(9bPiqlNJo5q,LLLplus,),@doc], │ [if] | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ true :: Value | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ val :: Identifier | [old,SL(HEPZqmkiKKP,Base.Docs,SL(9bPiqlNJo5q,LLLplus,)),@doc], │ │ file = "/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl" │ line = 500 └ mod = LLLplus ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538 =# - Found unexpected binding of kind static_parameter Expression:  #₃₉/Td Containing expressions:  (= #₈₅/Td #₃₉/Td)  (= #₁₄ (call core.svec (call core.svec #₇₉/#minimalpolynomial#ff##0 #₃₉/Td) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538:0))  (= #₁₄ (call core.svec (call core.svec (function_type #₄₆/ff) #₃₉/Td) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538:0))  Detailed provenance:  #₃₉/Td  ├─ Td  │ ├─ Td  │ │ └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:538  │ └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  │ └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  │ └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 =#) " minimalpolynomial(d,β::Td,p,verbose=false) where {Td<:Number}\n\nFind the minimal polynomial for some element 'α' of a field given the degree\n'd' of the polynomial, an approximation 'β' of 'α', and the number of\nsignificant (decimal) digits of precision 'p' in 'β'. Returns two things, a\nfunction, and a Bool indicating whether we think a true minimal polynomial\nwas found. The ouptut function takes a single argument of the same type as\n'β', and evaluates the estimated minimal polynomial over that argument.\n\nFollows technique in the following paper: \"A Gentle Tutorial for\nLattice-Based Cryptanalysis\" by Joseph Surin and Shaanan Cohney,\nhttps://eprint.iacr.org/2023/032\n\n# Example\n```jldoctest\njulia> minimalpolynomial(3,8.70997594,8,true);\nInputs:\n d=3, β=8.709976, Td=Float64, p=8\nOutput:\n f(x) = x^3 - 21x^2 + 147x^1 + -348\n\njulia> f,success = minimalpolynomial(3,8.70997594,9); success\nfalse\n\n```\n" (function (where (call minimalpolynomial d (:: β Td) p (kw verbose false)) (<: Td Number)) (block (= Ti (call getIntType Td)) (= B (call zeros Ti (call + d 1) (call + d 1))) (for (= ix (call : 1 (call + d 1))) (block (= (ref B 1 ix) (call floor (call * (call ^ 10 p) (call ^ β (call - ix 1))))))) (= (ref B (call : 2 (call + d 1)) (call : 1 d)) (call (curly Matrix Ti) I d d)) (= (tuple Bp _) (call lll B)) (= a (ref Bp (call : 2 (call + d 1)) 1)) (function (call ff (:: x Td)) (block (= s (call zero Td)) (for (= ix (call : 1 d)) (block (unknown_head s (call * (ref a ix) (call ^ x (call - ix 1)))))) (unknown_head s (call ^ x d)) (return s))) (= f (call ff β)) (= success true) (if (call < (call abs (call / β f)) (call ^ 10 p)) (block (= success false))) (if verbose (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:555 =#) "Inputs:\n d=%d, β=%f, Td=%s, p=%d\n" d β Td p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:556 =#) "Output:\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:557 =#) " f(x) = x^%d" d) (for (= ix (call : d -1 2)) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:559 =#) " %c %dx^%d" (if (call < (ref a ix) 0) '-' '+') (call abs (ref a ix)) (call - ix 1)))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:561 =#) " + %d\n" (ref a 1)) (if (call ~ success) (block (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:563 =#) "The results look off\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:564 =#) " For a high-precision β, we expect f(β)≈0, here f(β) = %f\n" f) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:565 =#) " We expected to see abs(β/f(β)) > 10^%d, but instead saw " p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:566 =#) "abs(β/f(β)) = %f\n" (call abs (call / β f))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:567 =#) " We expected abs(β/f)/10^p>1, here abs(β/f)/10^%d = %f\n" p (call / (call abs (call / β f)) (call ^ 10 p))) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:569 =#) " Maybe β did not have %d digits of precision.\n" p) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:570 =#) " or the minimal polynomial does not have degree %d.\n" d) (= x (ref (. abs (tuple (ref Bp : (call : 2 end)))) :)) (= aveB (call / (call sum x) (call length x))) (= ratio (call / (ref Bp 1 1) aveB)) (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:574 =#) " When succesful, we expect the ratio between the first element of\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:575 =#) " the shortest vector and the average of elements in other vectors\n") (macrocall @printf :(#= /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:576 =#) " to be small or less than 1. Here the ratio was %f \n" ratio))))) (return (tuple ff success)))))  └─ @ /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500  Stacktrace:  [1] _renumber(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ssa_rewrites::Dict{Int64, Int64}, slot_rewrites::Dict{Int64, Int64}, label_table::Dict{Int64, Int64}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1097  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1162  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1257  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1287  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:326  [7] top-level scope  @ ~/.julia/packages/LLLplus/wExHq/src/LLLplus.jl:38  [8] include(mod::Module, _path::String)  @ Base Base.jl:325  [9] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3303  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core boot.jl:522  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [13] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [15] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/LLLplus/wExHq/src/applications.jl:500 in expression starting at /home/pkgeval/.julia/packages/LLLplus/wExHq/src/LLLplus.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ LLLplus │ [Output was shown above] └ ERROR: LoadError: The following 1 package failed to precompile: LLLplus Failed to precompile LLLplus [142c1900-a1c3-58ae-a66d-b187f9ca6423] to "/home/pkgeval/.julia/compiled/v1.14/LLLplus/jl_7mNrtH" (ProcessExited(1)). in expression starting at /home/pkgeval/.julia/packages/LLLplus/wExHq/test/runtests.jl:4 Testing failed after 60.45s ERROR: LoadError: Package LLLplus errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 [8] include(mod::Module, _path::String) @ Base Base.jl:325 [9] exec_options(opts::Base.JLOptions) @ Base client.jl:355 [10] _start() @ Base client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 1534.71s: package fails to precompile